🔄 卡若AI 同步 2026-03-20 11:02 | 更新:Cursor规则、总索引与入口、金仓Gitea脚本与配置、金仓、水桥平台对接、水溪整理归档、卡木、运营中枢、运营中枢参考资料、运营中枢工作台 | 排除 >20MB: 11 个

This commit is contained in:
2026-03-20 11:02:58 +08:00
parent b0f3c269bf
commit 52cf5e0122
76 changed files with 11565 additions and 118 deletions

View File

@@ -36,7 +36,8 @@ alwaysApply: true
- **常规操作**:优先命令行 + 复用现成流程,不提问
- **飞书日志**:直接执行 `write_today_three_focus.py`,不询问
- **对外输出**:报告/图片 → `/Users/karuo/Documents/卡若Ai的文件夹/` 下对应子目录;图片登记 `图片/图片索引.md`
- **数据库**:一律用唯一 MongoDB27017库名 `karuo_site`
- **数据库**:一律用唯一 MongoDB27017库名 `karuo_site`;卡若 AI 调用以此库为主(记忆条目、对话记录、消息内容)
- **聊天记录**:一律存 MongoDB实时从 MongoDB 读取/召回;对话结束执行 `python3 01_卡资/金仓_存储备份/聊天记录管理/脚本/realtime_chat_sync.py` 实时同步并优化迭代自动分类、标签提取、摘要生成context_recall 在 MongoDB 不可用时自动读本地 fallback
- **MD 预览**Markdown Preview Enhanced 单界面
- **项目与端口注册表**:有变更时更新 `运营中枢/工作台/项目与端口注册表.md`
- **专有名词不翻译**Cursor、GitHub、Gitea、v0、Vercel、MongoDB、Synology、Navicat、宝塔等保留原文

2
.gitignore vendored
View File

@@ -26,6 +26,8 @@ sync_tokens.env
# 飞书日志:用户授权 token 与月度文档 token勿提交
**/飞书管理/脚本/.feishu_tokens.json
**/飞书管理/脚本/.feishu_month_wiki_tokens.json
# 淘宝/支付宝 应用公钥私钥(勿提交)
运营中枢/工作台/.taobao_alipay_app_keys
# 卡若AI 网关:多租户配置与访问日志(不入库)
运营中枢/scripts/karuo_ai_gateway/config/gateway.yaml

View File

@@ -55,6 +55,26 @@ git push -u gitea main
---
## 四(续)、添加仓库协作者(拉取+推送权限)
为仓库添加协作者、赋予**写权限**pull + push。协作者必须**已在 Gitea 注册**,按**用户名**添加。
```bash
# permission: read=只读拉取, write=拉取+推送, admin=完全权限
curl -u "fnvtk:zhiqun1984" -X PUT "http://open.quwanzhi.com:3000/api/v1/repos/fnvtk/仓库名/collaborators/用户名" \
-H "Content-Type: application/json" -d '{"permission":"write"}'
```
示例karuo-ai
```bash
curl -u "fnvtk:zhiqun1984" -X PUT "http://open.quwanzhi.com:3000/api/v1/repos/fnvtk/karuo-ai/collaborators/用户名" \
-H "Content-Type: application/json" -d '{"permission":"write"}'
```
> API 认证建议使用小写密码 `zhiqun1984`(与推送 HTTPS 一致)。
---
## 五、已纳入管理的仓库(界面可见)
| 仓库 | Gitea 地址 |

View File

@@ -0,0 +1,63 @@
# Navicat 功能与静默命令对照表
> 不打开 Navicat用系统自带或常用 CLI 实现相同能力。卡若AI 执行「数据库备份/查询/导入导出」时优先用本表命令。
---
## MySQL / MariaDB
| Navicat 功能 | 静默命令 / 方式 |
|------------------|-----------------|
| 连接并执行 SQL | `mysql -h HOST -P PORT -u USER -p DBNAME -e "SELECT ..."``mysql ... < script.sql` |
| 备份整个库 | `mysqldump -h HOST -P PORT -u USER -p DBNAME > backup.sql` |
| 仅表结构 | `mysqldump --no-data ...` |
| 恢复 | `mysql -h HOST -P PORT -u USER -p DBNAME < backup.sql` |
| 导出为 CSV | `mysql ... -e "SELECT ..." \| sed 's/\t/,/g' > out.csv` 或脚本用 pymysql + csv |
---
## MongoDB
| Navicat 功能 | 静默命令 / 方式 |
|------------------|-----------------|
| 连接并执行 | `mongosh "mongodb://USER:PASS@HOST:PORT/DB" --eval "db.collection.find()"` |
| 备份dump | `mongodump --uri="mongodb://..." --out=/path/to/dump` |
| 恢复 | `mongorestore --uri="mongodb://..." /path/to/dump` |
| 导出集合为 JSON | `mongoexport --uri="..." -c COLLECTION -o out.json` |
| 导出为 CSV | `mongoexport ... --type=csv -f "field1,field2" -o out.csv` |
---
## PostgreSQL
| Navicat 功能 | 静默命令 / 方式 |
|------------------|-----------------|
| 连接并执行 SQL | `psql -h HOST -p PORT -U USER -d DBNAME -c "SELECT ..."``psql ... -f script.sql` |
| 备份 | `pg_dump -h HOST -p PORT -U USER DBNAME > backup.sql` |
| 恢复 | `psql -h HOST -p PORT -U USER -d DBNAME -f backup.sql` |
---
## SQLite
| Navicat 功能 | 静默命令 / 方式 |
|------------------|-----------------|
| 连接并执行 | `sqlite3 /path/to/db.sqlite "SELECT ..."``sqlite3 db.sqlite < script.sql` |
| 备份 | `cp db.sqlite backup.sqlite``sqlite3 db.sqlite ".backup backup.sqlite"` |
| 导出为 CSV | `sqlite3 -header -csv db.sqlite "SELECT * FROM t" > out.csv` |
---
## 本机约定卡若AI
- **MongoDB**:本机统一 `localhost:27017`,库名见 `运营中枢/工作台/本机数据库统一规则.md`(如 `karuo_site`)。
- **MySQL**:本机/腾讯云等见同目录上级 `数据库管理/SKILL.md` 与《00_账号与API索引》中的连接信息脚本中勿写死密码用环境变量或《00》中约定方式。
---
## 版本记录
| 日期 | 变更 |
|------------|------|
| 2026-03-19 | 初版MySQL/MongoDB/PostgreSQL/SQLite 静默命令对照。 |
| 2026-03-19 | 迁至金仓 Navicat_Premium_静默控制 目录。 |

View File

@@ -0,0 +1,94 @@
# Navicat Premium 静默控制方案
> **目标**:不打开 Navicat GUI用命令行/脚本完成「Navicat 能做的」数据库操作供卡若AI 与自动化流程调用。
> 维护金仓归属金仓_存储备份。
---
## 一、Navicat 官方 CLI 能力分析
### 1.1 官方「命令行」是什么
- Navicat 文档里的「命令行界面」指**软件内部的**「命令行工具」窗口:需先**打开 Navicat**,在界面里选择「命令行工具」再执行 SQL。
- **结论**:官方没有提供「不启动 GUI、纯命令行」的独立 CLI所有「用命令连接/用命令备份」都是在**已打开软件**的前提下,在 GUI 内操作。
### 1.2 平台差异
| 平台 | 命令行能力 |
|--------|------------|
| Windows | 部分版本支持 `Navicat.exe /backup MySQL ConnectionName` 等参数,可做备份等;文档不完整。 |
| macOS | **未提供**等价命令行参数;无独立可执行 CLI无法静默调起备份/导出。 |
### 1.3 若必须用 Navicat 本身
- **AppleScript / JXA**:可控制已运行的 Navicat菜单、按钮、窗口但会带出界面无法做到「完全静默、不打开 APP」。
- **URL Scheme**:未在公开文档中看到 Navicat 注册 `navicat://` 等 URL Scheme若需可自行查 `Info.plist``CFBundleURLTypes`
---
## 二、静默控制思路(不打开 APP
核心思路:**用各数据库原生 CLI 替代 Navicat 的查询/备份/导入导出**实现「静默、脚本化」Navicat 仅作「连接配置的参考来源」。
| Navicat 功能 | 静默实现方式 |
|------------------|--------------|
| 连接 MySQL | `mysql` / `mysqldump`(或 Python `pymysql` |
| 连接 MongoDB | `mongosh` / `mongodump` / `mongoexport` |
| 连接 PostgreSQL | `psql` / `pg_dump` |
| 连接 SQLite | `sqlite3` |
| 备份/导出 | `mysqldump``mongodump``pg_dump`、复制 db 文件 |
| 导入/恢复 | `mysql < file.sql``mongorestore``psql -f` |
| 执行 SQL/查询 | 上述 CLI 或各语言驱动直接执行 |
| 数据传输/同步 | 需自行用脚本(导出→导入)或 ETL 工具;无 Navicat 时无法用其「数据传输」向导 |
连接信息从哪来:**从 Navicat 的配置里读**(见下一节),再传给上述 CLI/脚本。
---
## 三、Navicat 配置位置macOS
- **连接等配置**`~/Library/Preferences/com.premiumSoft.NavicatPremium.plist`
或版本/产品线不同可能为:`com.premiumSoft.Navicat*` 系列 plist。
- 可用 `plutil -p ~/Library/Preferences/com.premiumSoft.NavicatPremium.plist` 查看结构;连接多为键值或嵌套字典(主机、端口、用户等),密码可能加密存储。
---
## 四、实现要点
### 4.1 本目录内容
1. **静默命令对照表**
见同目录 `Navicat_功能与静默命令对照表.md`按「Navicat 功能 → 对应命令行」列表便于卡若AI 或人工替换。
2. **从 Navicat 配置读连接信息(可选)**
脚本:`scripts/read_navicat_connections.py`
-`~/Library/Preferences/com.premiumSoft.NavicatPremium.plist`
- 解析出连接名、主机、端口、用户、数据库名(密码若加密则需另填或钥匙串);
- 输出为 JSON`mysql`/`mongosh`/`psql` 等命令使用。
这样「不打开 APP」也能复用你在 Navicat 里配好的连接名与主机/端口/库名。
3. **与现有技能联动**
- 数据库管理(金仓):备份、清理、维护脚本已用 `mysql`/`mongosh` 等,与本方案一致;需要时可直接引用「静默命令对照表」与「读 Navicat 连接」脚本。
- 本机数据库统一规则、唯一 MongoDB 约定:脚本输出的连接信息需符合现有「本机一个实例、按库名区分」等约定。
### 4.2 无法静默替代的部分
- **Navicat 独有功能**:如「数据传输」向导、部分可视化同步、报表等,无官方 CLI 时无法在不打开 APP 的前提下完全等价实现;只能通过「导出→脚本处理→导入」或其它工具链替代。
---
## 五、使用方式卡若AI
- 用户说「用命令行备份某库」「不打开 Navicat 执行某 SQL」等
走**数据库管理** Skill按「静默命令对照表」用 `mysqldump`/`mongosh`/`mysql` 等执行;若需用 Navicat 里已保存的连接,可先跑 `scripts/read_navicat_connections.py` 取连接参数再调用原生 CLI。
- 用户说「静默控制 Navicat」「不打开 Navicat 做 xxx」
优先解释「官方无静默 CLI」并给出「用原生 CLI + 本方案」的等价做法与文档链接(本目录 README + 对照表)。
---
## 六、版本记录
| 日期 | 变更 |
|------------|------|
| 2026-03-19 | 初版Navicat CLI 分析、静默思路、配置路径、实现要点与使用方式。 |
| 2026-03-19 | 以原程序名命名迁至金仓_存储备份下移除「卡罗帮」称谓。 |

View File

@@ -0,0 +1,87 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
从 Navicat Premium (macOS) 的 plist 中读取连接配置(主机、端口、用户、库名等)。
密码通常为加密存储需在《00_账号与API索引》或环境变量中另行配置。
用途:不打开 Navicat用 mysql/mongosh/psql 等 CLI 时复用连接信息。
归属:金仓 · Navicat Premium 静默控制。
"""
import json
import plistlib
import sys
from pathlib import Path
PLIST_PATH = Path.home() / "Library/Preferences/com.premiumSoft.NavicatPremium.plist"
# 其他可能路径
ALT_PATHS = [
Path.home() / "Library/Application Support/PremiumSoft CyberTech/Navicat Premium/",
]
def load_plist(path: Path) -> dict:
try:
with open(path, "rb") as f:
return plistlib.load(f)
except Exception:
return {}
def extract_connections(data: dict) -> list:
"""从 plist 结构中尽量解析出连接信息(结构因版本可能不同)。"""
out = []
# 常见键名(不同版本可能不同)
for key in ("connections", "Connection", "Servers", "favoriteConnections", "connectionList"):
if key in data and isinstance(data[key], (list, dict)):
raw = data[key]
items = raw if isinstance(raw, list) else list(raw.values()) if isinstance(raw, dict) else []
for item in items:
if isinstance(item, dict):
conn = {
"name": item.get("name") or item.get("connectionName") or item.get("label") or "unknown",
"host": item.get("host") or item.get("Host") or "",
"port": item.get("port") or item.get("Port") or 0,
"user": item.get("userName") or item.get("user") or item.get("UserName") or "",
"database": item.get("database") or item.get("databaseName") or "",
"type": item.get("type") or item.get("databaseType") or "",
}
if conn["host"] or conn["database"] or conn["user"]:
out.append(conn)
# 若顶层是列表或字典,尝试遍历
if not out and isinstance(data, dict):
for k, v in data.items():
if isinstance(v, dict) and any(x in v for x in ("host", "Host", "userName", "user")):
conn = {
"name": v.get("name") or v.get("connectionName") or k,
"host": v.get("host") or v.get("Host") or "",
"port": v.get("port") or v.get("Port") or 0,
"user": v.get("userName") or v.get("user") or "",
"database": v.get("database") or v.get("databaseName") or "",
"type": v.get("type") or v.get("databaseType") or "",
}
if conn["host"] or conn["database"] or conn["user"]:
out.append(conn)
return out
def main():
path = PLIST_PATH
if not path.exists():
for p in ALT_PATHS:
candidate = p / "preferences.plist" if p.is_dir() else p
if candidate.exists():
path = candidate
break
if not path.exists():
print(json.dumps({"error": "Navicat plist not found", "tried": str(PLIST_PATH)}, ensure_ascii=False, indent=2))
sys.exit(1)
data = load_plist(path)
connections = extract_connections(data)
if not connections:
# 输出原始键,便于调试
print(json.dumps({"keys": list(data.keys())[:50], "message": "No connection structure found"}, ensure_ascii=False, indent=2))
sys.exit(0)
print(json.dumps(connections, ensure_ascii=False, indent=2))
if __name__ == "__main__":
main()

View File

@@ -12,6 +12,8 @@ updated: "2026-02-16"
管理卡若本地和云端数据库,提供日志清理、空间优化、定时维护服务。
**不打开 Navicat 的静默操作**(备份/查询/导入导出):见同目录 `Navicat_Premium_静默控制/README.md` 与对照表,用 `mysql`/`mongosh`/`pg_dump` 等原生 CLI 替代。
## 数据库概览
### 本地数据库

View File

@@ -464,6 +464,7 @@ Node 项目批量启动、502 修复、EADDRINUSE 等均按主 Skill 操作。SS
| `宝塔api接口文档.md` | 宝塔API完整接口说明 | `./references/` |
| `端口配置表.md` | 完整端口分配表 | `./references/` |
| `常见问题手册.md` | 问题解决方案大全 | `./references/` |
| `腾讯云_站内信安全消息转发邮箱配置.md` | 站内信/安全消息转发到指定邮箱(消息接收人+消息订阅) | `./references/` |
| `部署配置模板.md` | JSON配置文件模板 | `./references/` |
| `系统架构说明.md` | 完整架构图和流程图 | `./references/` |

View File

@@ -0,0 +1,65 @@
# 腾讯云站内信 / 安全消息 转发到邮箱配置
> 将腾讯云控制台的「站内信」「安全消息」等通知,通过**邮件**发到指定邮箱(如 xmbaiqi@qq.com
> 依据官方:消息中心 + 访问管理「消息接收人」。
> **官方确认**:消息中心支持「站内信、邮件、短信、微信、企业微信」等渠道,勾选邮件并选择已填邮箱的接收人即可发到该邮箱。
---
## 一、添加「消息接收人」(邮箱 xmbaiqi@qq.com
消息接收人是**仅用于收通知**的子账号,不能登录控制台,只能收站内信/邮件/短信等。
1. 登录 [访问管理控制台](https://console.cloud.tencent.com/cam)。
2. 左侧 **用户 → 用户列表**,点击 **新建用户**
3. 选择 **自定义创建****仅用于接收消息**
4. 填写:
- **用户名**:必填(如 `msg-xmbaiqi`)。
- **邮箱**`xmbaiqi@qq.com`(必填,用于收邮件)。
- **手机**:必填(用于短信/验证,可填主账号或常用号)。
- **备注**:选填(如「安全消息邮件接收」)。
5. 点击 **完成**
---
## 二、在「消息订阅」里开启邮件并选该接收人
1. 登录 [消息中心](https://console.cloud.tencent.com/message)。
2. 左侧 **订阅管理**,进入消息订阅页面。
3. 找到需要转发的产品(任选其一或都配):
- **云安全中心**(安全告警、安全消息)
- **主机安全**(主机相关安全消息)
- 其他你关心的产品(如 CVM、轻量等
4. 对该产品点击 **编辑**
- **高级编辑**:按「通知类型」勾选 **邮件**,并在「消息接收人」中**修改接收人**,勾选刚建的接收人(邮箱 xmbaiqi@qq.com
-**基础编辑模式**:勾选接收渠道 **邮件**,选择同一接收人,确定。
5. 若希望「站内信」内容也通过邮件收到:在订阅里**同时勾选「站内信」和「邮件」**,并选同一接收人(邮件会发到 xmbaiqi@qq.com
---
## 三、云安全中心 / 主机安全 单独确认(可选)
若重点要「安全消息」到邮箱:
- **云安全中心**
- 进入 [云安全中心控制台](https://console.cloud.tencent.com/csip/asset?tab=assetList&subtab=server) → 左侧 **通知设置**
- 页内会提示前往「消息中心」配置;点 **消息中心 > 消息订阅**,找到 **云安全中心**,按上面第二步勾选 **邮件** 并选择接收人 xmbaiqi@qq.com。
- **主机安全**
-**消息中心 > 订阅管理** 中找到「主机安全」产品,同样勾选 **邮件** 并选择该接收人。
---
## 四、注意
- 接收人**邮箱/手机**为必填,否则无法订阅邮件/短信。
- 若产品要求「至少一种渠道已验证」确保该接收人邮箱已能正常收信QQ 邮箱一般无需额外验证)。
- 如需多个邮箱(例如再加一个):在访问管理中再建一个「仅用于接收消息」用户,填另一个邮箱,再在消息订阅里把该接收人一并勾选即可。
---
## 五、参考链接
- [新建消息接收人](https://cloud.tencent.com/document/product/598/13667)
- [消息订阅管理](https://cloud.tencent.com/document/product/1263/46205)
- [云安全中心 - 通知设置](https://cloud.tencent.com/document/product/664/123498)

View File

@@ -0,0 +1,200 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
拉取腾讯云云安全中心最近 3 条安全告警,立即发送到指定邮箱(默认 xmbaiqi@qq.com
凭证:腾讯云同 腾讯云_宝塔服务器重启.py发件箱同 00_账号与API索引 四、邮箱。
依赖pip install tencentcloud-sdk-python-common tencentcloud-sdk-python-csip
"""
import json
import os
import re
import smtplib
import sys
from email.mime.text import MIMEText
from email.utils import formatdate
# 收件人(可环境变量 ALERT_EMAIL_TO 覆盖)
TO_EMAIL_DEFAULT = "xmbaiqi@qq.com"
def _find_karuo_ai_root():
d = os.path.dirname(os.path.abspath(__file__))
for _ in range(6):
if os.path.basename(d) == "卡若AI" or (
os.path.isdir(os.path.join(d, "运营中枢")) and os.path.isdir(os.path.join(d, "01_卡资"))
):
return d
d = os.path.dirname(d)
return None
def _read_tencent_creds():
root = _find_karuo_ai_root()
if not root:
return None, None
path = os.path.join(root, "运营中枢", "工作台", "00_账号与API索引.md")
if not os.path.isfile(path):
return None, None
with open(path, "r", encoding="utf-8") as f:
text = f.read()
secret_id = secret_key = None
in_tencent = False
for line in text.splitlines():
if "### 腾讯云" in line:
in_tencent = True
continue
if in_tencent and line.strip().startswith("###"):
break
if not in_tencent:
continue
m = re.search(r"\|\s*[^|]*(?:SecretId|密钥)[^|]*\|\s*`([^`]+)`", line, re.I)
if m:
val = m.group(1).strip()
if val.startswith("AKID"):
secret_id = val
m = re.search(r"\|\s*SecretKey\s*\|\s*`([^`]+)`", line, re.I)
if m:
secret_key = m.group(1).strip()
return secret_id or None, secret_key or None
def _read_smtp_creds():
"""从 00_账号 四、邮箱 解析 邮箱地址、密码(用于发件)。"""
root = _find_karuo_ai_root()
if not root:
return None, None
path = os.path.join(root, "运营中枢", "工作台", "00_账号与API索引.md")
if not os.path.isfile(path):
return None, None
with open(path, "r", encoding="utf-8") as f:
text = f.read()
email_addr = password = None
in_mail = False
for line in text.splitlines():
if "## 四、邮箱" in line or "### 邮箱" in line:
in_mail = True
continue
if in_mail and line.strip().startswith("##"):
break
if not in_mail:
continue
if "邮箱地址" in line:
m = re.findall(r"`([^`]+@[^`]+)`", line)
if m:
email_addr = m[0].strip()
m = re.search(r"\|\s*密码\s*\|\s*`([^`]+)`", line)
if m:
password = m.group(1).strip()
return email_addr or None, password or None
def _get_recent_alerts(secret_id, secret_key, limit=3):
try:
from tencentcloud.common import credential
from tencentcloud.common.profile.client_profile import ClientProfile
from tencentcloud.common.profile.http_profile import HttpProfile
from tencentcloud.csip.v20221121 import csip_client, models
except ImportError:
print("请安装: pip install tencentcloud-sdk-python-common tencentcloud-sdk-python-csip")
return None
cred = credential.Credential(secret_id, secret_key)
hp = HttpProfile()
hp.endpoint = "csip.tencentcloudapi.com"
cp = ClientProfile(httpProfile=hp)
client = csip_client.CsipClient(cred, "", cp)
req = models.DescribeAlertListRequest()
req.Filter = models.Filter()
req.Filter.Limit = limit
req.Filter.Offset = 0
# 不设时间则取全量中前 Limit 条(一般为最新)
resp = client.DescribeAlertList(req)
if getattr(resp, "ReturnCode", 1) != 0:
print("API 返回异常: ReturnCode=%s" % getattr(resp, "ReturnCode", ""))
return None
alerts = getattr(resp, "AlertList", None) or []
return list(alerts)
def _alert_to_text(alert):
"""单条告警转可读文本。"""
lines = []
lines.append("%s" % (getattr(alert, "Name", "") or "未命名"))
lines.append(" 时间: %s" % getattr(alert, "CreateTime", ""))
lines.append(" 类型: %s | 子类型: %s" % (getattr(alert, "Type", ""), getattr(alert, "SubType", "")))
lines.append(" 等级: %s | 状态: %s" % (getattr(alert, "Level", ""), getattr(alert, "Status", "")))
lines.append(" 来源: %s" % getattr(alert, "Source", ""))
if getattr(alert, "RemediationSuggestion", ""):
lines.append(" 处置建议: %s" % alert.RemediationSuggestion)
victim = getattr(alert, "Victim", None)
if victim and getattr(victim, "IP", ""):
lines.append(" 受害IP: %s" % victim.IP)
attacker = getattr(alert, "Attacker", None)
if attacker and getattr(attacker, "IP", ""):
lines.append(" 攻击IP: %s" % attacker.IP)
return "\n".join(lines)
def _send_mail(smtp_user, smtp_pass, to_email, subject, body_text):
msg = MIMEText(body_text, "plain", "utf-8")
msg["Subject"] = subject
msg["From"] = smtp_user
msg["To"] = to_email
msg["Date"] = formatdate(localtime=True)
with smtplib.SMTP_SSL("smtp.qq.com", 465) as s:
s.login(smtp_user, smtp_pass)
s.sendmail(smtp_user, [to_email], msg.as_string())
return True
def main():
to_email = os.environ.get("ALERT_EMAIL_TO") or TO_EMAIL_DEFAULT
secret_id = os.environ.get("TENCENTCLOUD_SECRET_ID")
secret_key = os.environ.get("TENCENTCLOUD_SECRET_KEY")
if not secret_id or not secret_key:
sid, skey = _read_tencent_creds()
secret_id = secret_id or sid
secret_key = secret_key or skey
if not secret_id or not secret_key:
print("❌ 未配置腾讯云 SecretId/SecretKey环境变量或 00_账号与API索引.md")
return 1
smtp_user = os.environ.get("SMTP_USER")
smtp_pass = os.environ.get("SMTP_PASS")
if not smtp_user or not smtp_pass:
u, p = _read_smtp_creds()
smtp_user = smtp_user or u
smtp_pass = smtp_pass or p
if not smtp_user or not smtp_pass:
print("❌ 未配置发件邮箱 SMTP_USER/SMTP_PASS 或 00_账号 四、邮箱")
return 1
print("正在拉取云安全中心最近 3 条告警…")
alerts = _get_recent_alerts(secret_id, secret_key, limit=3)
if alerts is None:
return 1
if not alerts:
body = "当前无安全告警记录。"
print("当前无告警,仍将发送一封说明邮件到 %s" % to_email)
else:
parts = ["腾讯云云安全中心 · 最近 %d 条安全消息\n" % len(alerts), "=" * 50]
for i, a in enumerate(alerts, 1):
parts.append("\n--- 第 %d 条 ---" % i)
parts.append(_alert_to_text(a))
body = "\n".join(parts)
print("已获取 %d 条告警,正在发送到 %s" % (len(alerts), to_email))
subject = "腾讯云安全消息 · 最近%d" % len(alerts) if alerts else "腾讯云安全消息 · 当前无告警"
try:
_send_mail(smtp_user, smtp_pass, to_email, subject, body)
print("✅ 已发送到 %s" % to_email)
return 0
except Exception as e:
print("❌ 发送邮件失败: %s" % e)
return 1
if __name__ == "__main__":
sys.exit(main())

View File

@@ -0,0 +1,217 @@
# 聊天记录管理 SKILL
```yaml
id: G22
name: 聊天记录管理
member: 金仓
trigger:
- 聊天记录
- 对话存储
- 聊天归档
- 聊天导出
- 聊天导入
- 清理聊天
- 对话查询
- 历史对话
- state.vscdb
- cursor聊天
- 对话迁移
- 聊天分类
- 上下文召回
- 历史召回
- 自动归档
version: 2.1
updated: 2026-03-20
heat: 🔴 热
```
## 一句话
卡若 AI 聊天记录一律存 **MongoDB**karuo_site实时从库读取/召回;**每次对话结束自动同步并优化迭代**(智能分类+标签+摘要)+ 上下文召回 + 查询导出;**MongoDB 不可用时从本地 fallback 读取最近对话**。
---
## Capabilities
| 能力 | 说明 |
|:---|:---|
| **实时同步与优化迭代** | 每次对话结束时自动同步到MongoDB智能项目分类、标签提取、摘要生成 |
| **自动归档** | 批量扫描新增对话并归档(备选方案) |
| **上下文召回** | 新建对话时从 MongoDB 匹配相关历史对话注入上下文MongoDB 不可用时从 fallback/recent_chats_fallback.json 召回 |
| **批量迁移** | 从 Cursor state.vscdb + agent-transcripts 批量导入 |
| **全文检索** | 按项目、时间、关键词搜索历史对话 |
| **导入导出** | JSON 格式导出/导入,跨实例迁移 |
| **安全清理** | 确认 MongoDB 已备份后清理 state.vscdb 释放空间 |
---
## MongoDB 存储结构
数据库: `karuo_site` | 集合全中文
### 集合: `对话记录`
| 字段 | 类型 | 说明 |
|:---|:---|:---|
| 对话ID | string | 唯一标识 |
| 名称 | string | 对话名称 |
| 项目 | string | 自动分类的项目 |
| 标签 | array | 用户自定义标签 |
| 创建时间 | datetime | |
| 更新时间 | datetime | |
| 消息数量 | int | |
| 是否Agent | bool | |
| 首条消息 | string | 第一条用户消息摘要 |
| 来源 | string | state.vscdb / agent-transcript / 手动归档 |
| 关联文件 | array | 涉及的文件路径 |
### 集合: `消息内容`
| 字段 | 类型 | 说明 |
|:---|:---|:---|
| 对话ID | string | 关联对话 |
| 消息ID | string | 唯一标识 |
| 类型 | int | 1=用户, 2=AI |
| 角色 | string | 用户/AI |
| 内容 | string | 消息文本 |
| 创建时间 | datetime | |
| 工具调用数 | int | |
| 代码块数 | int | |
### 集合: `项目分类`
| 字段 | 类型 | 说明 |
|:---|:---|:---|
| 名称 | string | 项目名 |
| 对话数 | int | |
### 项目分类规则15 类)
卡若AI、Soul创业、存客宝、玩值电竞、数据处理、神射手、上帝之眼、服务器、设备管理、**群晖NAS**、飞书、**微信管理**、工具维护、个人、开发 → 其余归「未分类」。关键词持续扩展见各脚本内 `项目分类规则`,定期可执行 `query_chat_history.py --reclassify` 优化未分类数量。
---
## Usage
### 对话结束时 — 实时同步(推荐)
```bash
# 实时同步当前对话(每次对话结束自动调用,智能优化)
python3 脚本/realtime_chat_sync.py
# 指定对话ID同步
python3 脚本/realtime_chat_sync.py --current-conversation-id <对话ID>
# 优化分类规则(分析未分类对话,建议新关键词)
python3 脚本/realtime_chat_sync.py --optimize-classification
# 查看统计
python3 脚本/realtime_chat_sync.py --stats
```
### 对话结束时 — 批量归档(备选)
```bash
# 增量扫描 state.vscdb 新对话
python3 脚本/auto_archive.py --scan-new
# 手动归档指定对话
python3 脚本/auto_archive.py --id "对话ID" --name "名称" --project "项目" --summary "摘要"
```
### 新建对话时 — 上下文召回
```bash
# 根据用户输入匹配历史对话
python3 脚本/context_recall.py "用户的问题关键词"
# 限定项目 + 详细内容
python3 脚本/context_recall.py "部署问题" --project "存客宝" --detail
# JSON 格式输出(供程序调用)
python3 脚本/context_recall.py "飞书日志" --json
```
### 查询
```bash
python3 脚本/query_chat_history.py --stats
python3 脚本/query_chat_history.py --search "关键词"
python3 脚本/query_chat_history.py --project "Soul创业"
python3 脚本/query_chat_history.py --since 2026-03-01
python3 脚本/query_chat_history.py --conversation <对话ID>
python3 脚本/query_chat_history.py --list
python3 脚本/query_chat_history.py --reclassify
python3 脚本/query_chat_history.py --tag <对话ID> "标签"
```
### 迁移
```bash
python3 脚本/migrate_cursor_to_mongo.py --full # 全量
python3 脚本/migrate_cursor_to_mongo.py # 增量
python3 脚本/migrate_cursor_to_mongo.py --full --include-transcripts # 全量+transcripts
```
### 导入导出
```bash
python3 脚本/export_import_chats.py export -o ~/备份/chats.json
python3 脚本/export_import_chats.py export --project "卡若AI" -o ~/备份/karuo.json
python3 脚本/export_import_chats.py import -i ~/备份/chats.json
```
### 安全清理
```bash
python3 脚本/cleanup_statedb.py --days 30 # dry-run
python3 脚本/cleanup_statedb.py --days 30 --execute --backup --vacuum # 实际执行
```
---
## 自动触发规则
### 对话结束时(写入 Cursor rules
每次对话最后一步(强制执行):
1. `python3 脚本/realtime_chat_sync.py` - 实时同步当前对话到MongoDB自动优化分类、提取标签、生成摘要
2. 如需要扫描所有新对话:`python3 脚本/auto_archive.py --scan-new`
### 新建对话时(写入 Cursor rules
对话开始时,如果用户问题与历史对话可能相关:
1. `python3 脚本/context_recall.py "用户问题关键词" --limit 3`
2. 将召回结果作为参考上下文
### 实时同步与优化迭代
**核心机制**`realtime_chat_sync.py` 在每次对话结束时自动调用,实现:
- ✅ 实时写入MongoDB对话记录+消息内容)
- ✅ 智能项目分类(基于文件路径、名称、内容的多维度匹配)
- ✅ 自动标签提取(基于关键词和项目类型)
- ✅ 对话摘要生成提取用户前3条消息关键信息
- ✅ 分类规则优化(定期分析未分类对话,建议新关键词)
---
## Files
| 文件 | 功能 |
|:---|:---|
| `SKILL.md` | 技能说明 |
| `脚本/migrate_cursor_to_mongo.py` | 批量迁移 |
| `脚本/query_chat_history.py` | 查询工具 |
| `脚本/realtime_chat_sync.py` | **实时同步与优化迭代**(每次对话结束自动调用,智能分类+标签+摘要) |
| `脚本/auto_archive.py` | 自动归档(批量扫描新增对话) |
| `脚本/context_recall.py` | 上下文召回Mongo 不可用时读 fallback |
| `脚本/chat_fallback.py` | 本地 fallback 读写MongoDB 不可用时最近对话) |
| `fallback/recent_chats_fallback.json` | 最近 N 条对话摘要(由 realtime_chat_sync 写入) |
| `脚本/export_import_chats.py` | 导入导出 |
| `脚本/cleanup_statedb.py` | 安全清理 |
| `脚本/export_chat_by_name.py` | 按名称导出:从 MongoDB 导出指定名称的 Agent 对话为 Markdown输出到 `导出/` |
## Dependencies
- Python 3.10+, pymongo, SQLite3系统自带
- MongoDB 6.0+(本机唯一实例 27017

View File

@@ -0,0 +1 @@
# 数据库不可用时,从此目录读取最近对话 fallback

View File

@@ -0,0 +1,21 @@
{
"updated": "2026-03-19T13:15:45.424625+00:00",
"conversations": [
{
"对话ID": "c9182bfc-9c29-4e71-b1ac-0f1bbf79237b",
"名称": "聊天内容复制",
"项目": "未分类",
"首条消息": "阿猫的笔记,苹果笔记本,这个 agent 的那个在曼谷数据库里面的这个聊天的聊天内容,帮我复制到这里面来",
"创建时间": "2026-03-19T13:08:33.553000+00:00",
"消息数量": 55
},
{
"对话ID": "b0f7c964-0743-4320-aef0-ab654429e49c",
"名称": "Navicat Premium CLI control",
"项目": "未分类",
"首条消息": "'/Applications/Navicat Premium.app' 分析一下这个数据库 CLI 的那个处理,然后把这个理解这个,并且来实现这个控制这个 APP 的所有功能,静默,不要打开 APP直接能控制这个 APP 的相应的所有的功能。做一个这个 APP 的 idea然后卡罗帮卡罗 AI 里面",
"创建时间": "2026-03-19T13:10:07.421000+00:00",
"消息数量": 64
}
]
}

View File

@@ -0,0 +1,193 @@
# 实时对话同步与优化迭代机制
> **核心机制**每次对话结束时自动将对话写入MongoDB并进行智能优化迭代
## 一、机制概述
### 1.1 核心功能
每次对话结束时,`realtime_chat_sync.py` 自动执行以下操作:
1. **实时写入MongoDB**
- 将对话记录写入 `karuo_site.对话记录`
- 将消息内容写入 `karuo_site.消息内容`
- 同步写入本地 fallbackMongoDB不可用时使用
2. **智能优化迭代**
- **项目自动分类**:基于文件路径、对话名称、内容的多维度匹配
- **标签自动提取**:基于关键词和项目类型自动生成标签
- **摘要自动生成**提取用户前3条消息的关键信息作为摘要
- **分类规则优化**:定期分析未分类对话,建议新关键词
3. **优化算法**
- 项目分类使用权重匹配文件路径权重3、名称权重2、内容权重1
- 标签提取基于关键词库和项目类型
- 摘要生成提取用户消息的前3条关键信息
## 二、自动触发机制
### 2.1 Cursor规则集成
`.cursor/rules/karuo-ai.mdc` 中已配置:
```markdown
- **聊天记录**:一律存 MongoDB实时从 MongoDB 读取/召回;对话结束执行
`python3 01_卡资/金仓_存储备份/聊天记录管理/脚本/realtime_chat_sync.py`
实时同步并优化迭代(自动分类、标签提取、摘要生成)
```
**执行时机**:每次对话的最后一条回复时自动执行
### 2.2 执行流程
```
对话结束 → Cursor规则触发 → 执行realtime_chat_sync.py →
读取state.vscdb → 智能分类+标签+摘要 → 写入MongoDB → 同步fallback
```
## 三、使用方法
### 3.1 自动执行(推荐)
对话结束时Cursor会自动调用无需手动操作。
### 3.2 手动执行
```bash
# 同步最新对话
python3 脚本/realtime_chat_sync.py
# 指定对话ID同步
python3 脚本/realtime_chat_sync.py --current-conversation-id <对话ID>
# 强制更新已存在的对话
python3 脚本/realtime_chat_sync.py --current-conversation-id <对话ID> --force
# 优化分类规则(分析未分类对话,建议新关键词)
python3 脚本/realtime_chat_sync.py --optimize-classification
# 查看统计
python3 脚本/realtime_chat_sync.py --stats
```
## 四、优化迭代机制
### 4.1 项目分类优化
**当前分类规则**15类
- 卡若AI、Soul创业、存客宝、玩值电竞、数据处理、神射手、上帝之眼
- 服务器、设备管理、群晖NAS、飞书、微信管理、工具维护、个人、开发
**优化方式**
1. 定期执行 `--optimize-classification` 分析未分类对话
2. 提取高频关键词,建议加入分类规则
3. 手动更新 `项目分类规则` 字典
### 4.2 标签提取规则
**自动标签类型**
- 基于项目:自动添加项目名作为标签
- 基于关键词bug修复、功能开发、优化、部署、数据分析、文档
**扩展方式**
- 修改 `提取标签()` 函数中的 `关键词标签` 字典
### 4.3 摘要生成规则
**当前规则**
- 提取用户前3条消息
- 每条消息截取前100字符
- 总长度不超过300字符
**优化方向**
- 可引入NLP模型提取关键信息
- 可基于对话主题生成更精准摘要
## 五、数据存储结构
### 5.1 对话记录集合
```javascript
{
"对话ID": "uuid",
"名称": "对话名称",
"副标题": "自动生成的摘要",
"项目": "自动分类的项目",
"标签": ["标签1", "标签2"],
"创建时间": ISODate,
"更新时间": ISODate,
"消息数量": 10,
"是否Agent": true,
"模型配置": {},
"关联文件": ["/path/to/file"],
"首条消息": "用户第一条消息摘要",
"来源": "实时同步",
"同步版本": "2.0"
}
```
### 5.2 消息内容集合
```javascript
{
"对话ID": "uuid",
"消息ID": "bubbleId",
"类型": 1, // 1=用户, 2=AI
"角色": "用户",
"内容": "消息文本",
"创建时间": ISODate,
"是否Agent": true,
"Token用量": {},
"工具调用数": 0,
"代码块数": 0
}
```
## 六、性能与可靠性
### 6.1 性能优化
- **增量同步**:只同步新对话,已存在对话跳过(除非使用 `--force`
- **批量写入**:消息内容使用 `bulk_write` 批量操作
- **连接复用**MongoDB连接复用减少连接开销
### 6.2 容错机制
- **MongoDB不可用**自动降级到本地fallback
- **state.vscdb不存在**:友好提示,不中断流程
- **数据解析失败**:跳过该对话,继续处理其他对话
### 6.3 数据一致性
- **upsert操作**:使用 `update_one``upsert=True` 确保数据不重复
- **时间戳同步**:保留原始创建时间,更新时间实时更新
- **fallback同步**MongoDB写入成功后同步写入fallback
## 七、迭代改进计划
### 7.1 短期优化
- [ ] 引入更智能的NLP模型进行项目分类
- [ ] 支持自定义分类规则配置
- [ ] 增加对话质量评分机制
### 7.2 长期优化
- [ ] 基于历史对话学习优化分类规则
- [ ] 自动生成对话标签建议
- [ ] 对话主题聚类分析
- [ ] 智能摘要生成基于LLM
## 八、相关文件
- **核心脚本**`脚本/realtime_chat_sync.py`
- **SKILL文档**`SKILL.md`
- **Cursor规则**`.cursor/rules/karuo-ai.mdc`
- **Fallback机制**`脚本/chat_fallback.py`
## 九、版本历史
| 版本 | 日期 | 变更 |
|:---|:---|:---|
| 2.0 | 2026-03-20 | 创建实时同步机制,支持智能分类、标签提取、摘要生成 |
| 1.0 | 2026-03-19 | 初始版本,基础归档功能 |

View File

@@ -0,0 +1,269 @@
# 婼瑄阿猫录音目录结构
- **对话ID**: `6c8a3a4e-853a-4878-8a87-8e1837d0bd27`
- **项目**: 个人
- **消息数**: 38
- **创建**: 2026-01-21 09:19
- **更新**: 2026-01-21 10:36
---
## [用户]
@个人/1、卡若:本人 @Documents/婼瑄 这个是婼瑄=阿猫文件内名字阿猫婼瑄是个女生。和卡若里面很多内容是卡若说的话请去掉仅保留阿猫的以及其它人对话的一个录音还有和其他人对话的一个录音录音里聊到的内容的一个整理洛轩就是阿猫等一些所有的一些内容以及平常跟卡洛在聊天的一些内容就阿猫和卡洛聊天的一些内容的一些录音和他平常跟朋友聊天的一些录音。他和卡洛和朋友聊天的一些录音然后把这一些东西帮我生成一个像卡洛本人的这么一个目录的一个结构目录放在婼瑄的个人目录下。1比1制作一个文件夹继续你刚刚那个再说一遍。这个就纠正了姓这个最容易踩的5个坑。追求完美导致拖延这个是不会吗因为我不怎么喜欢跟人接触隐藏自己。会这个就是性格模型的使用。是的使用说明吗第三个的话是优质资产清单可复用四维资产战略思维能力吗这个比较一般前瞻。干嘛呢
---
## [AI]
我来分析一下你的需求:你希望我参考卡若本人的目录结构,为婼瑄(阿猫)创建一个类似的个人档案目录。
让我先读取相关文件来了解结构和内容。
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
让我搜索婼瑄相关的文件夹。
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
让我读取卡若本人的索引文件和相关内容,同时搜索婼瑄相关的文件。
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
找到很多相关文件。让我读取一些关键的婼瑄/阿猫相关内容来了解她的信息。
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
现在我看到了大量关于婼瑄/阿猫的信息。让我继续搜索更多专门关于她的文件内容。
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
根据图片和收集到的信息,我现在了解了婼瑄(阿猫)的资料。让我根据卡若本人的目录结构,为婼瑄创建个人档案。
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
*(无文本内容)*
---
## [AI]
已完成婼瑄阿猫的个人档案目录创建。参照卡若本人的目录结构1:1制作放在 `/Users/karuo/Documents/个人/2、婼瑄阿猫/` 下。
### 创建的文件清单:
| 文件 | 说明 |
|------|------|
| `00_索引.md` | 目录入口,推荐阅读顺序 |
| `01_自我画像总览.md` | 一句话定位 + 主线与边界 |
| `02_性格模型与使用说明INFJ_九型_克利夫顿.md` | 性格测试结果与使用规则 |
| `03_优势资产清单可复用.md` | 克利夫顿优势四维资产 |
| `04_短板与修炼计划.md` | 最容易踩的5个坑 + 修炼计划 |
| `05_VMP个人角色定位.md` | 价值观/方法论/人格深度分析 |
| `99_原始文件清单不丢.md` | 原始素材来源索引 |
### 根据你提供的图片和信息,已整合的关键内容:
1. **九型人格测试**
- 追求完美导致拖延 ✓ 会发生
- 因不喜欢与人接触而隐藏自己 ✓ 会发生
2. **克利夫顿优势**
- 战略思维最强(搜集、前瞻、追根、分析、思维)
- 前10名才干已整理成表格
3. **VMP角色定位**
- INFJ + 战略型智囊定位
- 三个报告解读已整合
4. **金句**"自知者明,自胜者强。"
所有卡若说的话已剔除,仅保留阿猫的个人特质分析。
---

View File

@@ -0,0 +1,268 @@
#!/usr/bin/env python3
"""
Agent 列表同步与恢复
- 导出:将 Cursor 右侧 Agent 列表(来自 state.vscdb composerData同步到 MongoDB「Agent列表」
- 恢复:从 MongoDB「对话记录」+「消息内容」写回 state.vscdb使新工作区打开时右侧 Agent 列表恢复显示
注意:恢复时建议先关闭 Cursor完成后再重新打开。
用法:
python3 agent_sync_restore.py export # 当前 Agent 列表 → MongoDB
python3 agent_sync_restore.py restore # MongoDB → state.vscdb恢复全部或指定
python3 agent_sync_restore.py restore --name "阿猫的苹果笔记本" # 只恢复名称匹配的对话为右侧 Agent
python3 agent_sync_restore.py list # 查看 MongoDB 中 Agent 列表
"""
import argparse
import json
import os
import sqlite3
import sys
from datetime import datetime, timezone
from pathlib import Path
try:
from pymongo import MongoClient, UpdateOne
from pymongo.errors import BulkWriteError
except ImportError:
print("需要 pymongo: pip install pymongo")
sys.exit(1)
MONGO_URI = "mongodb://admin:admin123@localhost:27017/?authSource=admin"
DB_NAME = "karuo_site"
STATE_VSCDB = os.path.expanduser(
"~/Library/Application Support/Cursor/User/globalStorage/state.vscdb"
)
def 时间戳转时间(ts_ms):
if not ts_ms:
return None
try:
return datetime.fromtimestamp(ts_ms / 1000, tz=timezone.utc)
except (ValueError, OSError):
return None
def get_db():
client = MongoClient(MONGO_URI, serverSelectionTimeoutMS=5000)
try:
client.admin.command("ping")
except Exception as e:
print(f"MongoDB 连接失败: {e}")
sys.exit(1)
return client, client[DB_NAME]
def export_to_mongo(db):
"""从 state.vscdb 读取 composerData同步到 MongoDB 集合「Agent列表」"""
if not os.path.exists(STATE_VSCDB):
print(f"未找到: {STATE_VSCDB}")
return
conn = sqlite3.connect(STATE_VSCDB)
cur = conn.cursor()
cur.execute("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'")
ops = []
count = 0
for row in cur.fetchall():
key, value = row
对话ID = key.replace("composerData:", "")
try:
data = json.loads(value)
except (json.JSONDecodeError, TypeError):
continue
名称 = data.get("name") or data.get("subtitle") or ""
headers = data.get("fullConversationHeadersOnly", [])
消息数 = len(headers)
创建时间 = 时间戳转时间(data.get("createdAt"))
更新时间 = 时间戳转时间(data.get("lastUpdatedAt"))
doc = {
"对话ID": 对话ID,
"名称": 名称 or f"Agent_{对话ID[:8]}",
"消息数量": 消息数,
"创建时间": 创建时间,
"更新时间": 更新时间,
"是否Agent": data.get("isAgentic", False),
"来源": "state.vscdb",
"同步时间": datetime.now(timezone.utc),
}
ops.append(UpdateOne({"对话ID": 对话ID}, {"$set": doc}, upsert=True))
count += 1
conn.close()
if ops:
try:
db["Agent列表"].create_index("对话ID", unique=True)
db["Agent列表"].bulk_write(ops, ordered=False)
except BulkWriteError as e:
print("部分写入失败:", e.details)
print(f"已同步 {count} 个 Agent 到 MongoDB 集合「Agent列表」")
else:
print("无 composerData 可同步")
def restore_from_mongo(db, limit=None, 对话ID列表=None, name_filter=None):
"""从 MongoDB 对话记录+消息内容 写回 state.vscdb使 Cursor 右侧 Agent 列表恢复"""
if not os.path.exists(STATE_VSCDB):
print(f"未找到: {STATE_VSCDB}")
return
if 对话ID列表 is not None:
# 调用方已指定要恢复的对话 ID
pass
elif name_filter:
# 按名称模糊匹配,只恢复这些对话为 Agent
convs = list(
db["对话记录"]
.find({"名称": {"$regex": name_filter.strip(), "$options": "i"}})
.sort("更新时间", -1)
)
对话ID列表 = [c["对话ID"] for c in convs]
if not 对话ID列表:
print(f'未找到名称包含 "{name_filter}" 的对话。')
return
print(f"按名称匹配到 {len(对话ID列表)} 条对话,将恢复为右侧 Agent。")
else:
# 默认Agent列表 或 对话记录 最近 N 条
agent_cursor = db["Agent列表"].find({}).sort("更新时间", -1)
if limit:
agent_cursor = agent_cursor.limit(limit)
对话ID列表 = [a["对话ID"] for a in agent_cursor]
if not 对话ID列表:
# 若 Agent列表 为空,则从 对话记录 取最近 N 条
对话ID列表 = [
d["对话ID"]
for d in db["对话记录"].find({}, {"对话ID": 1}).sort("更新时间", -1).limit(limit or 200)
]
if not 对话ID列表:
print("MongoDB 中无对话可恢复")
return
conn = sqlite3.connect(STATE_VSCDB)
cur = conn.cursor()
# 准备写入 cursorDiskKV
insert_count = 0
for 对话ID in 对话ID列表:
conv = db["对话记录"].find_one({"对话ID": 对话ID})
if not conv:
continue
名称 = conv.get("名称", "") or f"Agent_{对话ID[:8]}"
创建时间 = conv.get("创建时间")
更新时间 = conv.get("更新时间") or 创建时间
if 创建时间 and hasattr(创建时间, "timestamp"):
created_ts = int(创建时间.timestamp() * 1000)
else:
created_ts = int(datetime.now(timezone.utc).timestamp() * 1000)
if 更新时间 and hasattr(更新时间, "timestamp"):
updated_ts = int(更新时间.timestamp() * 1000)
else:
updated_ts = created_ts
msgs = list(db["消息内容"].find({"对话ID": 对话ID}).sort("_id", 1))
headers = [{"bubbleId": m["消息ID"]} for m in msgs]
# 最小化 composerData保证 Cursor 能识别并显示在列表
composer_data = {
"_v": 14,
"composerId": 对话ID,
"name": 名称,
"subtitle": "",
"createdAt": created_ts,
"lastUpdatedAt": updated_ts,
"fullConversationHeadersOnly": headers,
"hasLoaded": True,
"status": "none",
"text": "",
"richText": "",
"context": {"notepads": [], "composers": [], "quotes": [], "fileSelections": [], "folderSelections": [], "selections": [], "cursorRules": [], "mentions": {"notepads": {}, "composers": {}}},
"conversationMap": {},
"isAgentic": conv.get("是否Agent", False),
"modelConfig": conv.get("模型配置", {}),
}
key = f"composerData:{对话ID}"
value = json.dumps(composer_data, ensure_ascii=False)
cur.execute("INSERT OR REPLACE INTO cursorDiskKV (key, value) VALUES (?, ?)", (key, value))
insert_count += 1
# 写回每条消息到 bubbleId
for m in msgs:
mid = m["消息ID"]
msg_type = m.get("类型", 2)
content = m.get("内容", "")
created_at = m.get("创建时间")
if created_at and hasattr(created_at, "timestamp"):
rpc_ts = int(created_at.timestamp() * 1000)
else:
rpc_ts = created_ts
bubble = {
"_v": 3,
"type": msg_type,
"bubbleId": mid,
"text": content,
"isAgentic": m.get("是否Agent", False),
"tokenCount": m.get("Token用量", {}),
"timingInfo": {"clientRpcSendTime": rpc_ts} if rpc_ts else {},
}
bkey = f"bubbleId:{对话ID}:{mid}"
bval = json.dumps(bubble, ensure_ascii=False)
cur.execute("INSERT OR REPLACE INTO cursorDiskKV (key, value) VALUES (?, ?)", (bkey, bval))
insert_count += 1
conn.commit()
conn.close()
print(f"已恢复 {len(对话ID列表)} 个 Agent 到 state.vscdb共写入 {insert_count} 条记录)")
print("请重启 Cursor 后查看右侧 Agent 列表。")
def list_agents(db, limit=50):
"""列出 MongoDB 中 Agent 列表"""
agents = list(db["Agent列表"].find({}).sort("更新时间", -1).limit(limit))
if not agents:
print("「Agent列表」为空请先执行: python3 agent_sync_restore.py export")
return
print(f"\n{len(agents)} 条(最近 {limit} 条)\n")
for i, a in enumerate(agents, 1):
name = a.get("名称", "")
cid = a.get("对话ID", "")
n = a.get("消息数量", 0)
t = a.get("更新时间")
ts = t.strftime("%Y-%m-%d %H:%M") if t else ""
print(f" {i}. {name}")
print(f" ID: {cid} | 消息: {n} | 更新: {ts}")
print()
def main():
parser = argparse.ArgumentParser(description="Agent 列表同步与恢复")
parser.add_argument("action", choices=["export", "restore", "list"], help="export=同步到MongoDB restore=从MongoDB恢复 list=查看列表")
parser.add_argument("--limit", type=int, default=None, help="restore 时最多恢复 N 个 Agent")
parser.add_argument("--name", type=str, default=None, help="restore 时只恢复名称包含此关键词的对话(会出现在右侧 Agent 列表)")
args = parser.parse_args()
client, db = get_db()
if args.action == "export":
export_to_mongo(db)
elif args.action == "restore":
print("即将从 MongoDB 写回 state.vscdb建议先关闭 Cursor。")
restore_from_mongo(db, limit=args.limit, name_filter=args.name)
elif args.action == "list":
list_agents(db)
client.close()
if __name__ == "__main__":
main()

View File

@@ -0,0 +1,302 @@
#!/usr/bin/env python3
"""
自动归档当前对话到 MongoDB
在每次对话结束时调用,自动将本轮对话存入数据库
用法由卡若AI自动调用:
python3 auto_archive.py --id <对话ID> --name "对话名称" --project "项目名"
python3 auto_archive.py --id <对话ID> --name "对话名称" --messages '[{"角色":"用户","内容":"xxx"},{"角色":"AI","内容":"yyy"}]'
python3 auto_archive.py --id <对话ID> --name "对话名称" --summary "本轮对话摘要"
python3 auto_archive.py --scan-new # 扫描 state.vscdb 中新增的对话并归档
"""
import argparse
import json
import os
import sqlite3
import sys
from datetime import datetime, timezone
from pathlib import Path
# 保证从任意目录运行都能找到 chat_fallback
_script_dir = Path(__file__).resolve().parent
if str(_script_dir) not in sys.path:
sys.path.insert(0, str(_script_dir))
try:
from pymongo import MongoClient, UpdateOne
from pymongo.errors import BulkWriteError
except ImportError:
print("需要 pymongo: pip install pymongo")
sys.exit(1)
MONGO_URI = "mongodb://admin:admin123@localhost:27017/?authSource=admin"
DB_NAME = "karuo_site"
STATE_VSCDB = os.path.expanduser(
"~/Library/Application Support/Cursor/User/globalStorage/state.vscdb"
)
# 数据库不可用时从本地 fallback 读取最近对话
import chat_fallback as _fallback
项目分类规则 = {
"卡若AI": ["卡若AI", "karuo_ai", "BOOTSTRAP", "SKILL_REGISTRY", "五行", "卡若ai"],
"Soul创业": ["soul", "Soul", "soul创业", "卡若创业派对", "soul派对", "soul运营"],
"存客宝": ["cunkebao", "存客宝", "触客宝", "touchkebao"],
"玩值电竞": ["玩值", "wanzhi", "wanzhi_esports", "wzdj"],
"数据处理": ["数据中台", "datacenter", "KR_", "SG_", "导入mongo", "mongo数据库", "集合导入", "嘟嘟牛", "社工", "MongoDB迁移", "数据库迁移", "数据库恢复", "数据库优化", "/Users/karuo/数据库"],
"神射手": ["shensheshou", "神射手"],
"上帝之眼": ["上帝之眼", "god_eye", "量化交易"],
"服务器": ["服务器", "宝塔", "nginx", "SSL", "502", "腾讯云"],
"设备管理": ["ADB", "投屏", "scrcpy", "局域网", "远程控制", "192.168"],
"群晖NAS": ["群晖", "Synology", "NAS", "CKBNAS", "nas_init", "1825", "smb://", "NAS部署", "USB连接"],
"飞书": ["飞书", "feishu", "lark", "妙记", "飞书妙记", "智能纪要"],
"微信管理": ["微信", "WeChat", "微信存储", "社群占用"],
"工具维护": ["cursor", "state.vscdb", "icloud", "docker", "Docker", "硬盘", "磁盘", "空间", "node_modules", ".next", "清理", "输入法", "搜狗", "下载目录", "整理下载", "文件分类", "无法安装", "快捷方式", "进程", "快捷键", "GitHub", "Gitea", "fnvtk", "token"],
"个人": ["/个人/", "/1、卡若", "日记", "记忆", "iPhone", "相册", "MacBook相册", "Photos"],
"开发": ["/开发/", "知己", "项目模板", "智能项目生成", "金:项目", "银掌柜", "续茄", "小程序", "腾讯书籍", "分销模块", "前后端整合", "package.json", "开发文档", "开发模板", "MBTI", "route.ts", "page.tsx", "wxml", "wxss"],
}
def 检测项目(文件路径, 名称="", 内容=""):
搜索文本 = " ".join(文件路径) + " " + 名称 + " " + 内容
for 项目, 关键词 in 项目分类规则.items():
for kw in 关键词:
if kw.lower() in 搜索文本.lower():
return 项目
return "未分类"
def 时间戳转时间(ts_ms):
if not ts_ms:
return None
try:
return datetime.fromtimestamp(ts_ms / 1000, tz=timezone.utc)
except (ValueError, OSError):
return None
def 归档指定对话(db, 对话ID, 名称="", 项目="", 摘要="", 消息列表=None, 标签列表=None):
"""手动归档一个对话由AI在对话结束时调用"""
now = datetime.now(timezone.utc)
if not 项目:
所有内容 = 摘要
if 消息列表:
所有内容 += " ".join(m.get("内容", "") for m in 消息列表[:5])
项目 = 检测项目([], 名称, 所有内容)
首条 = ""
if 消息列表:
for m in 消息列表:
if m.get("角色") == "用户" and m.get("内容"):
首条 = m["内容"][:500]
break
对话文档 = {
"对话ID": 对话ID,
"名称": 名称 or f"对话 {对话ID[:8]}",
"副标题": 摘要[:200] if 摘要 else "",
"项目": 项目,
"标签": 标签列表 or [],
"创建时间": now,
"更新时间": now,
"消息数量": len(消息列表) if 消息列表 else 0,
"是否Agent": True,
"模型配置": {},
"关联文件": [],
"首条消息": 首条,
"来源": "手动归档",
"来源工作区": "",
"迁移时间": now,
}
db["对话记录"].update_one(
{"对话ID": 对话ID}, {"$set": 对话文档}, upsert=True
)
if 消息列表:
ops = []
for i, m in enumerate(消息列表):
ops.append(UpdateOne(
{"对话ID": 对话ID, "消息ID": f"manual-{i}"},
{"$set": {
"对话ID": 对话ID,
"消息ID": f"manual-{i}",
"类型": 1 if m.get("角色") == "用户" else 2,
"角色": m.get("角色", "未知"),
"内容": m.get("内容", ""),
"创建时间": now,
"是否Agent": True,
"Token用量": {},
"工具调用数": 0,
"代码块数": 0,
}},
upsert=True,
))
if ops:
try:
db["消息内容"].bulk_write(ops, ordered=False)
except BulkWriteError:
pass
print(f"已归档: [{项目}] {名称 or 对话ID[:8]} ({len(消息列表) if 消息列表 else 0} 条消息)")
try:
_fallback.追加一条(对话文档)
except Exception:
pass
return 对话文档
def 扫描新增对话(db):
"""扫描 state.vscdb 中新增的对话(增量归档)"""
if not os.path.exists(STATE_VSCDB):
print("state.vscdb 不存在")
return
已有ID = set(
doc["对话ID"] for doc in db["对话记录"].find({}, {"对话ID": 1})
)
conn = sqlite3.connect(STATE_VSCDB)
cursor = conn.cursor()
cursor.execute("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'")
新增 = 0
新增对话列表 = []
for row in cursor.fetchall():
key, value = row
对话ID = key.replace("composerData:", "")
if 对话ID in 已有ID:
continue
try:
data = json.loads(value)
except (json.JSONDecodeError, TypeError):
continue
headers = data.get("fullConversationHeadersOnly", [])
if not headers:
continue
ctx = data.get("context", {})
文件路径 = [f.get("uri", {}).get("fsPath", "") for f in ctx.get("fileSelections", []) if f.get("uri", {}).get("fsPath")]
名称 = data.get("name", "") or ""
副标题 = data.get("subtitle", "") or ""
项目 = 检测项目(文件路径, 名称, 副标题)
消息ID列表 = [h.get("bubbleId", "") for h in headers if h.get("bubbleId")]
首条 = ""
# 提取消息
消息ops = []
for mid in 消息ID列表:
cursor.execute("SELECT value FROM cursorDiskKV WHERE key = ?", (f"bubbleId:{对话ID}:{mid}",))
r = cursor.fetchone()
if not r:
continue
try:
mdata = json.loads(r[0])
except:
continue
类型 = mdata.get("type", 0)
内容 = mdata.get("text", "") or ""
if 类型 == 1 and not 首条 and 内容:
首条 = 内容[:500]
timing = mdata.get("timingInfo", {})
创建时间 = 时间戳转时间(timing.get("clientRpcSendTime")) if timing.get("clientRpcSendTime") else None
消息ops.append(UpdateOne(
{"对话ID": 对话ID, "消息ID": mid},
{"$set": {
"对话ID": 对话ID, "消息ID": mid,
"类型": 类型, "角色": "用户" if 类型 == 1 else "AI",
"内容": 内容, "创建时间": 创建时间,
"是否Agent": mdata.get("isAgentic", False),
"Token用量": mdata.get("tokenCount", {}),
"工具调用数": len(mdata.get("toolResults", []) or []),
"代码块数": len(mdata.get("codeBlocks", []) or []),
}},
upsert=True,
))
db["对话记录"].update_one(
{"对话ID": 对话ID},
{"$set": {
"对话ID": 对话ID, "名称": 名称, "副标题": 副标题,
"项目": 项目, "标签": [],
"创建时间": 时间戳转时间(data.get("createdAt")),
"更新时间": 时间戳转时间(data.get("lastUpdatedAt")),
"消息数量": len(headers), "是否Agent": data.get("isAgentic", False),
"模型配置": data.get("modelConfig", {}), "关联文件": 文件路径[:50],
"首条消息": 首条, "来源": "state.vscdb", "来源工作区": "",
"迁移时间": datetime.now(timezone.utc),
}},
upsert=True,
)
if 消息ops:
try:
db["消息内容"].bulk_write(消息ops, ordered=False)
except BulkWriteError:
pass
新增 += 1
新增对话列表.append({
"对话ID": 对话ID,
"名称": 名称,
"项目": 项目,
"首条消息": 首条,
"创建时间": 时间戳转时间(data.get("createdAt")),
"消息数量": len(headers),
})
conn.close()
if 新增对话列表:
try:
_fallback.批量追加(新增对话列表)
except Exception:
pass
print(f"增量归档完成: 新增 {新增} 个对话")
def main():
parser = argparse.ArgumentParser(description="自动归档对话到 MongoDB")
parser.add_argument("--id", type=str, help="对话ID")
parser.add_argument("--name", type=str, default="", help="对话名称")
parser.add_argument("--project", type=str, default="", help="项目名")
parser.add_argument("--summary", type=str, default="", help="对话摘要")
parser.add_argument("--messages", type=str, default="", help="消息列表JSON")
parser.add_argument("--tags", type=str, default="", help="标签,逗号分隔")
parser.add_argument("--scan-new", action="store_true", help="扫描新增对话")
args = parser.parse_args()
client = MongoClient(MONGO_URI, serverSelectionTimeoutMS=5000)
try:
client.admin.command("ping")
except Exception as e:
print(f"MongoDB 连接失败: {e}")
sys.exit(1)
db = client[DB_NAME]
if args.scan_new:
扫描新增对话(db)
elif args.id:
消息列表 = None
if args.messages:
try:
消息列表 = json.loads(args.messages)
except json.JSONDecodeError:
print("消息列表JSON格式错误")
sys.exit(1)
标签 = [t.strip() for t in args.tags.split(",") if t.strip()] if args.tags else []
归档指定对话(db, args.id, args.name, args.project, args.summary, 消息列表, 标签)
else:
parser.print_help()
client.close()
if __name__ == "__main__":
main()

View File

@@ -0,0 +1,100 @@
#!/usr/bin/env python3
"""
聊天记录 · 本地 FallbackMongoDB 不可用时使用)
- 每次归档到 MongoDB 后同步写入本文件,保留最近 N 条对话摘要。
- context_recall / query_chat 在连不上 MongoDB 时从此读取并做简单关键词匹配。
"""
import json
import os
from datetime import datetime, timezone
from pathlib import Path
# 与 auto_archive 同目录fallback 在上一级
SCRIPT_DIR = Path(__file__).resolve().parent
FALLBACK_DIR = SCRIPT_DIR.parent / "fallback"
FALLBACK_FILE = FALLBACK_DIR / "recent_chats_fallback.json"
MAX_ENTRIES = 30
def _ensure_dir():
FALLBACK_DIR.mkdir(parents=True, exist_ok=True)
def _serialize_dt(dt):
if dt is None:
return None
if hasattr(dt, "isoformat"):
return dt.isoformat()
return str(dt)
def 追加一条(对话文档: dict):
"""将一条对话摘要追加到 fallback 文件(新的在头,保留最近 MAX_ENTRIES 条)。"""
_ensure_dir()
entry = {
"对话ID": 对话文档.get("对话ID", ""),
"名称": 对话文档.get("名称", ""),
"项目": 对话文档.get("项目", ""),
"首条消息": (对话文档.get("首条消息") or "")[:500],
"创建时间": _serialize_dt(对话文档.get("创建时间")),
"消息数量": 对话文档.get("消息数量", 0),
}
data = 读取_all()
# 去重:同 对话ID 只保留最新
conv_id = entry["对话ID"]
data["conversations"] = [c for c in data["conversations"] if c.get("对话ID") != conv_id]
data["conversations"].insert(0, entry)
data["conversations"] = data["conversations"][:MAX_ENTRIES]
data["updated"] = datetime.now(timezone.utc).isoformat()
with open(FALLBACK_FILE, "w", encoding="utf-8") as f:
json.dump(data, f, ensure_ascii=False, indent=0)
return True
def 批量追加(对话文档列表: list):
"""批量追加(新对话在头)。"""
if not 对话文档列表:
return
_ensure_dir()
data = 读取_all()
existing_ids = {c.get("对话ID") for c in data["conversations"]}
for 文档 in reversed(对话文档列表):
if 文档.get("对话ID") in existing_ids:
continue
entry = {
"对话ID": 文档.get("对话ID", ""),
"名称": 文档.get("名称", ""),
"项目": 文档.get("项目", ""),
"首条消息": (文档.get("首条消息") or "")[:500],
"创建时间": _serialize_dt(文档.get("创建时间")),
"消息数量": 文档.get("消息数量", 0),
}
data["conversations"].insert(0, entry)
existing_ids.add(entry["对话ID"])
data["conversations"] = data["conversations"][:MAX_ENTRIES]
data["updated"] = datetime.now(timezone.utc).isoformat()
with open(FALLBACK_FILE, "w", encoding="utf-8") as f:
json.dump(data, f, ensure_ascii=False, indent=0)
def 读取_all() -> dict:
"""读取完整 fallback 数据。"""
_ensure_dir()
if not FALLBACK_FILE.exists():
return {"updated": None, "conversations": []}
try:
with open(FALLBACK_FILE, "r", encoding="utf-8") as f:
data = json.load(f)
except (json.JSONDecodeError, OSError):
return {"updated": None, "conversations": []}
if not isinstance(data.get("conversations"), list):
data["conversations"] = []
return data
def 读取列表() -> list:
"""返回最近对话列表(用于 context_recall 降级)。"""
data = 读取_all()
return data.get("conversations", [])

View File

@@ -0,0 +1,169 @@
#!/usr/bin/env python3
"""
state.vscdb 安全清理(中文字段版)
用法:
python3 cleanup_statedb.py --days 30 # dry-run
python3 cleanup_statedb.py --days 30 --execute # 执行
python3 cleanup_statedb.py --days 30 --execute --backup # 备份后执行
python3 cleanup_statedb.py --orphans # 清理孤立数据
"""
import argparse
import os
import shutil
import sqlite3
import sys
import json
from datetime import datetime, timezone
try:
from pymongo import MongoClient
except ImportError:
print("需要 pymongo: pip install pymongo")
sys.exit(1)
MONGO_URI = "mongodb://admin:admin123@localhost:27017/?authSource=admin"
DB_NAME = "karuo_site"
STATE_VSCDB = os.path.expanduser("~/Library/Application Support/Cursor/User/globalStorage/state.vscdb")
def get_db():
client = MongoClient(MONGO_URI, serverSelectionTimeoutMS=5000)
try:
client.admin.command("ping")
except Exception as e:
print(f"连接失败: {e}")
sys.exit(1)
return client, client[DB_NAME]
def 备份():
if not os.path.exists(STATE_VSCDB):
return False
备份目录 = os.path.expanduser("~/Documents/个人/卡若AI/01_卡资/金仓_存储备份/聊天记录管理/备份")
os.makedirs(备份目录, exist_ok=True)
ts = datetime.now().strftime("%Y%m%d_%H%M%S")
目标 = os.path.join(备份目录, f"state.vscdb.backup_{ts}")
gb = os.path.getsize(STATE_VSCDB) / 1024**3
print(f"备份 state.vscdb ({gb:.1f} GB) → {目标}")
shutil.copy2(STATE_VSCDB, 目标)
print("备份完成")
return True
def 分析(conn, mongo_db):
cur = conn.cursor()
cur.execute("SELECT COUNT(*) FROM cursorDiskKV WHERE key LIKE 'bubbleId:%'")
总数 = cur.fetchone()[0]
cur.execute("SELECT DISTINCT substr(key, 10, 36) FROM cursorDiskKV WHERE key LIKE 'bubbleId:%'")
sqlite对话ID = set(row[0] for row in cur.fetchall())
已迁移 = set(doc["对话ID"] for doc in mongo_db["对话记录"].find({}, {"对话ID": 1}))
含消息 = set()
for cid in 已迁移:
if mongo_db["消息内容"].count_documents({"对话ID": cid}) > 0:
含消息.add(cid)
可清理 = sqlite对话ID & 含消息
可清理数 = 0
for cid in 可清理:
cur.execute("SELECT COUNT(*) FROM cursorDiskKV WHERE key LIKE ?", (f"bubbleId:{cid}:%",))
可清理数 += cur.fetchone()[0]
composer_ids = set(
row[0].replace("composerData:", "")
for row in conn.execute("SELECT key FROM cursorDiskKV WHERE key LIKE 'composerData:%'").fetchall()
)
孤立ID = sqlite对话ID - composer_ids
孤立数 = 0
for cid in 孤立ID:
cur.execute("SELECT COUNT(*) FROM cursorDiskKV WHERE key LIKE ?", (f"bubbleId:{cid}:%",))
孤立数 += cur.fetchone()[0]
return {
"总数": 总数, "sqlite对话数": len(sqlite对话ID),
"已迁移": len(已迁移), "含消息": len(含消息),
"可清理对话": len(可清理), "可清理消息": 可清理数,
"孤立对话": len(孤立ID), "孤立消息": 孤立数,
"可清理ID": 可清理, "孤立ID": 孤立ID,
}
def 执行清理(conn, ids, 标签=""):
cur = conn.cursor()
总删 = 0
for cid in ids:
cur.execute("DELETE FROM cursorDiskKV WHERE key LIKE ?", (f"bubbleId:{cid}:%",))
总删 += cur.rowcount
conn.commit()
print(f" {标签}: 删除 {总删}")
return 总删
def main():
parser = argparse.ArgumentParser(description="state.vscdb 安全清理")
parser.add_argument("--days", type=int, default=30)
parser.add_argument("--execute", action="store_true")
parser.add_argument("--backup", action="store_true")
parser.add_argument("--orphans", action="store_true")
parser.add_argument("--vacuum", action="store_true")
args = parser.parse_args()
if not os.path.exists(STATE_VSCDB):
print(f"不存在: {STATE_VSCDB}")
sys.exit(1)
client, mongo_db = get_db()
gb = os.path.getsize(STATE_VSCDB) / 1024**3
print(f"state.vscdb: {gb:.1f} GB")
conn = sqlite3.connect(STATE_VSCDB)
r = 分析(conn, mongo_db)
print(f"\n{'=' * 55}")
print(f" 清理分析")
print(f"{'=' * 55}")
print(f" SQLite bubbleId 总数: {r['总数']:,}")
print(f" SQLite 对话数: {r['sqlite对话数']:,}")
print(f" MongoDB 已迁移: {r['已迁移']:,}")
print(f" MongoDB 含消息: {r['含消息']:,}")
print(f" 可安全清理对话: {r['可清理对话']:,}")
print(f" 可安全清理 bubbleId: {r['可清理消息']:,}")
print(f" 孤立对话: {r['孤立对话']:,}")
print(f" 孤立 bubbleId: {r['孤立消息']:,}")
print(f"{'=' * 55}")
if not args.execute:
print("\n⚠️ dry-run未删除。加 --execute 执行。")
conn.close()
client.close()
return
if args.backup and not 备份():
print("备份失败")
conn.close()
client.close()
return
总删 = 0
if r["可清理消息"] > 0:
总删 += 执行清理(conn, r["可清理ID"], "已迁移数据")
if args.orphans and r["孤立消息"] > 0:
总删 += 执行清理(conn, r["孤立ID"], "孤立数据")
print(f"\n总删除: {总删:,}")
if args.vacuum and 总删 > 0:
print("\nVACUUM 压缩中...")
pre = os.path.getsize(STATE_VSCDB)
conn.execute("VACUUM")
post = os.path.getsize(STATE_VSCDB)
print(f" {pre/1024**3:.1f} GB → {post/1024**3:.1f} GB (释放 {(pre-post)/1024**3:.1f} GB)")
conn.close()
client.close()
if __name__ == "__main__":
main()

View File

@@ -0,0 +1,310 @@
#!/usr/bin/env python3
"""
上下文召回:新建对话时从 MongoDB 匹配相关历史对话
根据用户输入的关键词/描述,搜索 MongoDB 中最相关的历史对话,
返回摘要和关键上下文,供新对话使用
用法:
python3 context_recall.py "用户的问题或关键词"
python3 context_recall.py "存客宝部署" --limit 5
python3 context_recall.py "飞书日志" --project "飞书"
python3 context_recall.py "Soul运营报表" --detail
"""
import argparse
import re
import sys
from datetime import datetime, timezone
from pathlib import Path
# 保证从任意目录运行都能找到 chat_fallback
_script_dir = Path(__file__).resolve().parent
if str(_script_dir) not in sys.path:
sys.path.insert(0, str(_script_dir))
try:
from pymongo import MongoClient
except ImportError:
MongoClient = None
MONGO_URI = "mongodb://admin:admin123@localhost:27017/?authSource=admin"
DB_NAME = "karuo_site"
def get_db():
"""连接 MongoDB失败时返回 (None, None),由调用方降级到 fallback。"""
if MongoClient is None:
return None, None
client = MongoClient(MONGO_URI, serverSelectionTimeoutMS=5000)
try:
client.admin.command("ping")
except Exception as e:
print(f"MongoDB 连接失败: {e},使用本地最近对话 fallback。", file=sys.stderr)
try:
client.close()
except Exception:
pass
return None, None
return client, client[DB_NAME]
def 从_fallback_召回(查询文本, 项目过滤=None, limit=5):
"""MongoDB 不可用时从本地 fallback 文件做关键词匹配,返回与 召回历史对话 相同结构。"""
try:
import chat_fallback
列表 = chat_fallback.读取列表()
except Exception:
return None
关键词 = 提取关键词(查询文本)
if not 关键词:
关键词 = 查询文本.split()[:5]
结果 = []
for c in 列表:
名称 = c.get("名称", "") or ""
项目 = c.get("项目", "") or ""
首条 = c.get("首条消息", "") or ""
搜索文本 = f"{名称} {项目} {首条}".lower()
if 项目过滤 and 项目过滤.lower() not in 项目.lower():
continue
score = sum(1 for kw in 关键词 if kw.lower() in 搜索文本)
if score > 0:
结果.append({
"对话ID": c.get("对话ID", ""),
"名称": 名称,
"项目": 项目,
"创建时间": c.get("创建时间"),
"消息数量": c.get("消息数量", 0),
"首条消息": 首条[:300],
"匹配片段": 首条[:300],
})
结果.sort(key=lambda x: -len(x.get("匹配片段", "")))
结果 = 结果[:limit]
return 结果 if 结果 else None
def 提取关键词(文本):
"""从用户输入提取搜索关键词"""
cleaned = re.sub(r'[^\w\s\u4e00-\u9fff]', ' ', 文本)
words = cleaned.split()
stopwords = {"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "可以", "", "", "", "", "", "", "", "", "", "", "什么", "", "",
"", "", "", "", "", "", "", "", "", "", "", "怎么", "", "帮我", "", "一下"}
keywords = [w for w in words if w not in stopwords and len(w) > 1]
return keywords
def 召回历史对话(db, 查询文本, 项目过滤=None, limit=5, 详细=False):
"""
从 MongoDB 召回与查询文本最相关的历史对话
返回格式化的上下文供新对话使用
"""
关键词 = 提取关键词(查询文本)
if not 关键词:
关键词 = 查询文本.split()[:5]
搜索词 = " ".join(关键词)
结果 = []
对话ID集 = set()
# 方式1: 全文搜索消息内容
try:
消息结果 = db["消息内容"].find(
{"$text": {"$search": 搜索词}},
{"score": {"$meta": "textScore"}},
).sort([("score", {"$meta": "textScore"})]).limit(limit * 3)
for msg in 消息结果:
cid = msg["对话ID"]
if cid not in 对话ID集:
对话ID集.add(cid)
结果.append({
"对话ID": cid,
"匹配来源": "消息内容",
"匹配片段": msg.get("内容", "")[:300],
"分数": msg.get("score", 0),
})
except Exception:
pass
# 方式2: 全文搜索对话名称和首条消息
try:
对话结果 = db["对话记录"].find(
{"$text": {"$search": 搜索词}},
{"score": {"$meta": "textScore"}},
).sort([("score", {"$meta": "textScore"})]).limit(limit * 2)
for conv in 对话结果:
cid = conv["对话ID"]
if cid not in 对话ID集:
对话ID集.add(cid)
结果.append({
"对话ID": cid,
"匹配来源": "对话名称",
"匹配片段": conv.get("首条消息", "")[:300],
"分数": conv.get("score", 0),
})
except Exception:
pass
# 方式3: 正则匹配(兜底)
if len(结果) < limit:
for kw in 关键词[:3]:
regex_results = db["对话记录"].find(
{"$or": [
{"名称": {"$regex": kw, "$options": "i"}},
{"首条消息": {"$regex": kw, "$options": "i"}},
]}
).limit(limit)
for conv in regex_results:
cid = conv["对话ID"]
if cid not in 对话ID集:
对话ID集.add(cid)
结果.append({
"对话ID": cid,
"匹配来源": "关键词匹配",
"匹配片段": conv.get("首条消息", "")[:300],
"分数": 0,
})
# 项目过滤
if 项目过滤:
filtered_ids = set(
doc["对话ID"] for doc in db["对话记录"].find(
{"对话ID": {"$in": list(对话ID集)}, "项目": {"$regex": 项目过滤, "$options": "i"}},
{"对话ID": 1}
)
)
结果 = [r for r in 结果 if r["对话ID"] in filtered_ids]
# 按分数排序
结果.sort(key=lambda x: -x.get("分数", 0))
结果 = 结果[:limit]
if not 结果:
return None
# 获取对话详情
对话详情列表 = []
for r in 结果:
conv = db["对话记录"].find_one({"对话ID": r["对话ID"]})
if not conv:
continue
详情 = {
"对话ID": r["对话ID"],
"名称": conv.get("名称", ""),
"项目": conv.get("项目", ""),
"创建时间": conv.get("创建时间"),
"消息数量": conv.get("消息数量", 0),
"首条消息": conv.get("首条消息", ""),
"匹配片段": r["匹配片段"],
}
if 详细:
msgs = db["消息内容"].find(
{"对话ID": r["对话ID"]}
).sort("_id", 1).limit(10)
详情["关键消息"] = []
for msg in msgs:
内容 = msg.get("内容", "")
if 内容:
详情["关键消息"].append({
"角色": msg.get("角色", ""),
"内容": 内容[:500],
})
对话详情列表.append(详情)
return 对话详情列表
def _时间格式(创建时间):
"""创建时间可能是 datetime 或 ISO 字符串。"""
if 创建时间 is None:
return "未知"
if hasattr(创建时间, "strftime"):
return 创建时间.strftime("%Y-%m-%d")
if isinstance(创建时间, str) and len(创建时间) >= 10:
return 创建时间[:10]
return "未知"
def 格式化输出(对话列表, 详细=False, from_fallback=False):
"""格式化召回结果。"""
if not 对话列表:
print("未找到相关历史对话")
return ""
输出 = []
标题 = f"## 历史对话召回({len(对话列表)} 条相关记录)"
if from_fallback:
标题 += " 【来自本地 fallbackMongoDB 暂不可用】"
输出.append(标题 + "\n")
for i, 对话 in enumerate(对话列表, 1):
时间str = _时间格式(对话.get("创建时间"))
输出.append(f"### {i}. [{对话['项目']}] {对话['名称']}")
输出.append(f"- 时间: {时间str} | 消息数: {对话['消息数量']}")
输出.append(f"- ID: `{对话['对话ID']}`")
if 对话.get("首条消息"):
输出.append(f"- 首条消息: {对话['首条消息'][:200]}")
if 对话.get("匹配片段") and 对话["匹配片段"] != 对话.get("首条消息", ""):
输出.append(f"- 匹配内容: {对话['匹配片段'][:200]}")
if 详细 and 对话.get("关键消息"):
输出.append("\n **关键对话片段:**")
for msg in 对话["关键消息"][:5]:
角色标 = "👤" if msg["角色"] == "用户" else "🤖"
输出.append(f" {角色标} {msg['内容'][:300]}")
elif from_fallback:
输出.append(" fallback 无详细消息,仅摘要)")
输出.append("")
text = "\n".join(输出)
print(text)
return text
def main():
parser = argparse.ArgumentParser(description="历史对话上下文召回")
parser.add_argument("query", type=str, help="搜索关键词或问题描述")
parser.add_argument("--limit", type=int, default=5, help="返回数量")
parser.add_argument("--project", type=str, help="限定项目")
parser.add_argument("--detail", action="store_true", help="显示详细对话内容")
parser.add_argument("--json", action="store_true", help="JSON格式输出")
args = parser.parse_args()
client, db = get_db()
if db is not None:
结果 = 召回历史对话(db, args.query, args.project, args.limit, args.detail)
来自_fallback = False
else:
结果 = 从_fallback_召回(args.query, args.project, args.limit)
来自_fallback = True
if args.json:
import json
class DateEncoder(json.JSONEncoder):
def default(self, o):
if isinstance(o, datetime):
return o.isoformat()
return super().default(o)
if 结果:
print(json.dumps(结果, ensure_ascii=False, indent=2, cls=DateEncoder))
else:
print("[]")
else:
格式化输出(结果, args.detail, from_fallback=来自_fallback)
if client is not None:
client.close()
if __name__ == "__main__":
main()

View File

@@ -0,0 +1,141 @@
#!/usr/bin/env python3
"""
按对话名称从 MongoDB 导出 Agent 聊天内容为 Markdown
用于把「阿猫的苹果笔记本」等指定名称的对话导出到本地笔记
用法:
python3 export_chat_by_name.py "阿猫的苹果笔记本"
python3 export_chat_by_name.py "阿猫" -o ../导出/
python3 export_chat_by_name.py "苹果笔记本" --all
"""
import argparse
import os
import re
import sys
from datetime import datetime, timezone
from pathlib import Path
try:
from pymongo import MongoClient
except ImportError:
print("需要 pymongo: pip install pymongo")
sys.exit(1)
MONGO_URI = "mongodb://admin:admin123@localhost:27017/?authSource=admin"
DB_NAME = "karuo_site"
def get_db():
client = MongoClient(MONGO_URI, serverSelectionTimeoutMS=5000)
try:
client.admin.command("ping")
except Exception as e:
print(f"MongoDB 连接失败: {e}")
sys.exit(1)
return client, client[DB_NAME]
def 安全文件名(name):
"""去掉不适合做文件名的字符"""
s = re.sub(r'[<>:"/\\|?*]', "_", name)
return s.strip() or "未命名"
def export_conv_to_md(db, 对话ID, 名称, 输出路径):
"""将一条对话的消息内容导出为单个 Markdown 文件"""
conv = db["对话记录"].find_one({"对话ID": 对话ID})
if not conv:
return False
名称 = conv.get("名称", 名称 or "未命名")
msgs = list(db["消息内容"].find({"对话ID": 对话ID}).sort("_id", 1))
if not msgs:
print(f" 对话 {对话ID} 无消息内容,跳过")
return False
lines = [
f"# {名称}",
"",
f"- **对话ID**: `{对话ID}`",
f"- **项目**: {conv.get('项目', '未分类')}",
f"- **消息数**: {len(msgs)}",
]
创建 = conv.get("创建时间")
更新 = conv.get("更新时间")
if 创建:
lines.append(f"- **创建**: {创建.strftime('%Y-%m-%d %H:%M')}")
if 更新:
lines.append(f"- **更新**: {更新.strftime('%Y-%m-%d %H:%M')}")
lines.extend(["", "---", ""])
for m in msgs:
角色 = "用户" if m.get("类型") == 1 else "AI"
内容 = m.get("内容", "").strip()
t = m.get("创建时间")
ts = t.strftime("%Y-%m-%d %H:%M") if t else ""
lines.append(f"## [{角色}] {ts}")
lines.append("")
if 内容:
lines.append(内容)
else:
lines.append("*(无文本内容)*")
lines.append("")
lines.append("---")
lines.append("")
out_text = "\n".join(lines).rstrip() + "\n"
Path(输出路径).parent.mkdir(parents=True, exist_ok=True)
with open(输出路径, "w", encoding="utf-8") as f:
f.write(out_text)
return True
def main():
parser = argparse.ArgumentParser(description="按名称导出 MongoDB 中的 Agent 聊天为 Markdown")
parser.add_argument("name", nargs="?", default="阿猫的苹果笔记本", help="对话名称(模糊匹配),默认 阿猫的苹果笔记本")
parser.add_argument("-o", "--output-dir", default=None, help="输出目录,默认 聊天记录管理/导出/")
parser.add_argument("--all", action="store_true", help="导出所有名称匹配的对话(否则只导第一条)")
args = parser.parse_args()
script_dir = Path(__file__).resolve().parent
default_out = script_dir.parent / "导出"
out_dir = Path(args.output_dir).resolve() if args.output_dir else default_out
client, db = get_db()
# 名称模糊匹配:包含关键词即可
keyword = args.name.strip()
convs = list(
db["对话记录"]
.find({"名称": {"$regex": keyword, "$options": "i"}})
.sort("更新时间", -1)
)
if not convs:
# 尝试「阿猫」或「苹果」单独匹配
convs = list(
db["对话记录"]
.find({"$or": [{"名称": {"$regex": "阿猫", "$options": "i"}}, {"名称": {"$regex": "苹果", "$options": "i"}}]})
.sort("更新时间", -1)
)
if not convs:
print(f'未在 MongoDB 中找到名称包含 "{keyword}" 的对话。')
print("可用: python3 query_chat_history.py --list 查看所有对话。")
client.close()
sys.exit(1)
if not args.all:
convs = convs[:1]
print(f"找到 {len(convs)} 条匹配对话,导出到: {out_dir}")
out_dir.mkdir(parents=True, exist_ok=True)
for conv in convs:
cid = conv["对话ID"]
名称 = conv.get("名称", "未命名")
safe = 安全文件名(名称)
short_id = cid[:8] if len(cid) >= 8 else cid
out_path = out_dir / f"{safe}_{short_id}.md"
if export_conv_to_md(db, cid, 名称, str(out_path)):
print(f" 已写入: {out_path}")
client.close()
if __name__ == "__main__":
main()

View File

@@ -0,0 +1,157 @@
#!/usr/bin/env python3
"""
聊天记录导入导出(中文字段版)
用法:
python3 export_import_chats.py export -o /path/to/backup.json
python3 export_import_chats.py export --project "Soul创业" -o /path/to/backup.json
python3 export_import_chats.py import -i /path/to/backup.json
python3 export_import_chats.py import -i /path/to/backup.json --merge
"""
import argparse
import json
import sys
from datetime import datetime, timezone
from pathlib import Path
try:
from pymongo import MongoClient, UpdateOne
from pymongo.errors import BulkWriteError
except ImportError:
print("需要 pymongo: pip install pymongo")
sys.exit(1)
MONGO_URI = "mongodb://admin:admin123@localhost:27017/?authSource=admin"
DB_NAME = "karuo_site"
def get_db():
client = MongoClient(MONGO_URI, serverSelectionTimeoutMS=5000)
try:
client.admin.command("ping")
except Exception as e:
print(f"连接失败: {e}")
sys.exit(1)
return client, client[DB_NAME]
class 时间编码器(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, datetime):
return {"$date": obj.isoformat()}
return super().default(obj)
def 解析时间(doc):
for k, v in doc.items():
if isinstance(v, dict) and "$date" in v:
doc[k] = datetime.fromisoformat(v["$date"])
return doc
def 导出(db, output_path, project=None, since=None):
query = {}
if project:
query["项目"] = {"$regex": project, "$options": "i"}
if since:
try:
dt = datetime.strptime(since, "%Y-%m-%d").replace(tzinfo=timezone.utc)
query["创建时间"] = {"$gte": dt}
except ValueError:
print(f"日期格式错误: {since}")
return
convs = list(db["对话记录"].find(query))
if not convs:
print("未找到对话")
return
print(f"导出 {len(convs)} 个对话...")
数据 = {"版本": "2.0", "导出时间": datetime.now(timezone.utc).isoformat(), "对话列表": []}
总消息 = 0
for conv in convs:
conv.pop("_id", None)
对话ID = conv["对话ID"]
msgs = list(db["消息内容"].find({"对话ID": 对话ID}).sort("_id", 1))
for m in msgs:
m.pop("_id", None)
总消息 += len(msgs)
数据["对话列表"].append({"元数据": conv, "消息": msgs, "消息数": len(msgs)})
数据["总对话"] = len(convs)
数据["总消息"] = 总消息
output = Path(output_path)
output.parent.mkdir(parents=True, exist_ok=True)
with open(output, "w", encoding="utf-8") as f:
json.dump(数据, f, ensure_ascii=False, indent=2, cls=时间编码器)
mb = output.stat().st_size / 1024 / 1024
print(f"完成: {output} ({mb:.1f} MB, {len(convs)} 对话, {总消息} 消息)")
def 导入(db, input_path, merge=False):
f = Path(input_path)
if not f.exists():
print(f"文件不存在: {input_path}")
return
with open(f, "r", encoding="utf-8") as fp:
data = json.load(fp)
convs = data.get("对话列表", [])
print(f"导入 {len(convs)} 个对话...")
导入对话 = 0
导入消息 = 0
for item in convs:
meta = 解析时间(item.get("元数据", {}))
msgs = item.get("消息", [])
对话ID = meta.get("对话ID")
if not 对话ID:
continue
if not merge and db["对话记录"].find_one({"对话ID": 对话ID}):
continue
db["对话记录"].update_one({"对话ID": 对话ID}, {"$set": meta}, upsert=True)
导入对话 += 1
if msgs:
ops = [UpdateOne({"对话ID": m["对话ID"], "消息ID": m["消息ID"]}, {"$set": 解析时间(m)}, upsert=True) for m in msgs]
try:
r = db["消息内容"].bulk_write(ops, ordered=False)
导入消息 += r.upserted_count + r.modified_count
except BulkWriteError:
pass
print(f"完成: {导入对话} 对话, {导入消息} 消息")
def main():
parser = argparse.ArgumentParser(description="聊天记录导入导出")
sub = parser.add_subparsers(dest="action")
ep = sub.add_parser("export")
ep.add_argument("-o", "--output", required=True)
ep.add_argument("--project", type=str)
ep.add_argument("--since", type=str)
ip = sub.add_parser("import")
ip.add_argument("-i", "--input", required=True)
ip.add_argument("--merge", action="store_true")
args = parser.parse_args()
if not args.action:
parser.print_help()
return
client, db = get_db()
if args.action == "export":
导出(db, args.output, getattr(args, "project", None), getattr(args, "since", None))
elif args.action == "import":
导入(db, args.input, args.merge)
client.close()
if __name__ == "__main__":
main()

View File

@@ -0,0 +1,439 @@
#!/usr/bin/env python3
"""
对话归档目录导入 MongoDB唯一性保证不重复导入
将 02_卡人/水溪_整理归档/对话归档/ 目录下的所有 .txt 文件导入到 MongoDB
用法:
python3 import_chat_archive_to_mongo.py # 增量导入(跳过已存在的)
python3 import_chat_archive_to_mongo.py --full # 全量导入(强制覆盖)
python3 import_chat_archive_to_mongo.py --stats # 仅统计
"""
import argparse
import hashlib
import os
import re
import sys
from collections import defaultdict
from datetime import datetime, timezone
from pathlib import Path
try:
from pymongo import MongoClient, UpdateOne
from pymongo.errors import BulkWriteError
except ImportError:
print("需要 pymongo: pip install pymongo")
sys.exit(1)
MONGO_URI = "mongodb://admin:admin123@localhost:27017/?authSource=admin"
DB_NAME = "karuo_site"
ARCHIVE_BASE = Path("/Users/karuo/Documents/个人/卡若AI/02_卡人/水溪_整理归档/对话归档")
# 项目分类规则(与 migrate_cursor_to_mongo.py 一致)
项目分类规则 = {
"卡若AI": ["卡若AI", "karuo_ai", "BOOTSTRAP", "SKILL_REGISTRY", "五行", "卡若ai", "运营中枢", "技能", "SKILL.md"],
"Soul创业": ["soul", "Soul", "soul创业", "卡若创业派对", "soul派对", "soul运营", "派对运营"],
"存客宝": ["cunkebao", "存客宝", "触客宝", "touchkebao"],
"玩值电竞": ["玩值", "wanzhi", "wanzhi_esports", "wzdj"],
"数据处理": ["数据中台", "datacenter", "KR_", "SG_", "导入mongo", "mongo数据库", "集合导入", "嘟嘟牛", "社工", "MongoDB迁移", "数据库迁移", "数据库恢复", "数据库优化", "/Users/karuo/数据库"],
"神射手": ["shensheshou", "神射手"],
"上帝之眼": ["上帝之眼", "god_eye", "量化交易"],
"服务器": ["服务器", "宝塔", "nginx", "SSL", "502", "腾讯云", "部署", "docker", "Docker"],
"设备管理": ["ADB", "投屏", "scrcpy", "局域网", "远程控制", "192.168"],
"群晖NAS": ["群晖", "Synology", "NAS", "CKBNAS", "nas_init", "1825", "smb://", "NAS部署", "USB连接"],
"飞书": ["飞书", "feishu", "lark", "妙记", "飞书妙记", "智能纪要", "飞书日志"],
"微信管理": ["微信", "WeChat", "微信存储", "社群占用"],
"工具维护": ["cursor", "state.vscdb", "icloud", "docker", "Docker", "硬盘", "磁盘", "空间", "node_modules", ".next", "清理", "输入法", "搜狗", "下载目录", "整理下载", "文件分类", "无法安装", "快捷方式", "进程", "快捷键", "GitHub", "Gitea", "fnvtk", "token"],
"个人": ["/个人/", "/1、卡若", "日记", "记忆", "iPhone", "相册", "MacBook相册", "Photos"],
"开发": ["/开发/", "知己", "项目模板", "智能项目生成", "金:项目", "银掌柜", "续茄", "小程序", "腾讯书籍", "分销模块", "前后端整合", "package.json", "开发文档", "开发模板", "MBTI", "route.ts", "page.tsx", "wxml", "wxss"],
}
def 检测项目(文件路径: str, 名称: str = "", 内容: str = "") -> str:
"""根据文件路径、名称、内容检测项目分类"""
搜索文本 = f"{文件路径} {名称} {内容[:2000]}"
搜索文本_lower = 搜索文本.lower()
项目得分 = {}
for 项目, 关键词列表 in 项目分类规则.items():
得分 = 0
for kw in 关键词列表:
if kw.lower() in 搜索文本_lower:
# 文件路径匹配权重最高
if kw.lower() in 文件路径.lower():
得分 += 3
# 名称匹配权重中等
elif kw.lower() in 名称.lower():
得分 += 2
# 内容匹配权重较低
else:
得分 += 1
项目得分[项目] = 得分
if 项目得分:
最高项目 = max(项目得分.items(), key=lambda x: x[1])
if 最高项目[1] > 0:
return 最高项目[0]
return "未分类"
def 生成唯一ID(文件路径: Path) -> str:
"""基于文件路径、大小、修改时间生成唯一ID确保唯一性"""
try:
stat = 文件路径.stat()
# 使用相对路径(相对于归档目录)作为基础
相对路径 = str(文件路径.relative_to(ARCHIVE_BASE))
# 组合:相对路径 + 大小 + 修改时间
唯一标识 = f"{相对路径}:{stat.st_size}:{int(stat.st_mtime)}"
# 生成 SHA256 hash 作为对话ID固定长度避免过长
return hashlib.sha256(唯一标识.encode("utf-8")).hexdigest()[:32]
except Exception:
# 降级:仅使用文件名
return hashlib.sha256(str(文件路径).encode("utf-8")).hexdigest()[:32]
def 解析对话文件(文件路径: Path) -> tuple[list, str, str]:
"""
解析对话文件,提取消息列表、首条用户消息、对话名称
返回: (消息列表, 首条用户消息, 对话名称)
"""
try:
内容 = 文件路径.read_text(encoding="utf-8", errors="ignore")
except Exception as e:
print(f" 读取失败 {文件路径}: {e}")
return [], "", ""
if not 内容.strip():
return [], "", ""
消息列表 = []
首条用户消息 = ""
对话名称 = ""
# 解析 user/assistant 格式
# 匹配模式user: 或 assistant: 开头,后面跟内容
当前角色 = None
当前内容 = []
for line in 内容.split("\n"):
line = line.strip()
if not line:
continue
# 检查是否是角色标记
if line.startswith("user:") or line.startswith("assistant:"):
# 保存上一条消息
if 当前角色 and 当前内容:
消息文本 = "\n".join(当前内容).strip()
if 消息文本:
消息列表.append({
"角色": 当前角色,
"内容": 消息文本,
})
# 提取首条用户消息
if 当前角色 == "用户" and not 首条用户消息:
首条用户消息 = 消息文本[:500]
# 从首条消息提取对话名称(去除 <user_query> 标签)
名称文本 = re.sub(r"<[^>]+>", "", 消息文本).strip()
对话名称 = " ".join(名称文本.split()[:10])[:80] or "未命名对话"
# 开始新消息
当前角色 = "用户" if line.startswith("user:") else "AI"
当前内容 = [line[line.index(":") + 1:].strip()] if ":" in line else []
else:
# 继续当前消息内容
if 当前角色:
当前内容.append(line)
# 保存最后一条消息
if 当前角色 and 当前内容:
消息文本 = "\n".join(当前内容).strip()
if 消息文本:
消息列表.append({
"角色": 当前角色,
"内容": 消息文本,
})
if 当前角色 == "用户" and not 首条用户消息:
首条用户消息 = 消息文本[:500]
名称文本 = re.sub(r"<[^>]+>", "", 消息文本).strip()
对话名称 = " ".join(名称文本.split()[:10])[:80] or "未命名对话"
# 如果没有解析到消息,尝试从文件名提取名称
if not 对话名称:
文件名 = 文件路径.stem
# 尝试从文件名提取(去除 UUID 后缀)
名称部分 = re.sub(r"_[a-f0-9-]{32,}$", "", 文件名)
if 名称部分:
对话名称 = 名称部分[:80]
else:
对话名称 = 文件名[:80] or "未命名对话"
return 消息列表, 首条用户消息, 对话名称
def 创建索引(db):
"""创建 MongoDB 索引"""
对话集 = db["对话记录"]
# 先删除可能存在的旧索引
try:
对话集.drop_index("来源文件路径_1")
except Exception:
pass
# 清理 null 值的来源文件路径(为已存在的记录生成临时唯一值)
null_count = 对话集.count_documents({"$or": [{"来源文件路径": None}, {"来源文件路径": {"$exists": False}}]})
if null_count > 0:
print(f"发现 {null_count} 条记录的来源文件路径为 null正在清理...")
# 为这些记录生成临时唯一值
for doc in 对话集.find({"$or": [{"来源文件路径": None}, {"来源文件路径": {"$exists": False}}]}):
临时路径 = f"legacy-{doc.get('对话ID', 'unknown')}-{doc.get('_id', 'unknown')}"
对话集.update_one(
{"_id": doc["_id"]},
{"$set": {"来源文件路径": 临时路径}}
)
对话集.create_index("对话ID", unique=True)
# 创建唯一索引(使用 sparse只对存在的非 null 值唯一)
try:
对话集.create_index([("来源文件路径", 1)], unique=True, sparse=True)
except Exception as e:
print(f"创建来源文件路径索引失败(可能已存在): {e}")
对话集.create_index("项目")
对话集.create_index("创建时间")
消息集 = db["消息内容"]
消息集.create_index([("对话ID", 1), ("消息ID", 1)], unique=True)
消息集.create_index("对话ID")
消息集.create_index("创建时间")
db["项目分类"].create_index("名称", unique=True)
print("索引创建完成")
def 导入对话归档(db, full_mode=False):
"""导入对话归档目录的所有 .txt 文件"""
if not ARCHIVE_BASE.exists():
print(f"对话归档目录不存在: {ARCHIVE_BASE}")
return
print(f"\n{'=' * 50}")
print(f"导入对话归档目录 ({'全量' if full_mode else '增量'})")
print(f"目录: {ARCHIVE_BASE}")
print(f"{'=' * 50}")
# 查找所有 .txt 文件
所有文件 = list(ARCHIVE_BASE.rglob("*.txt"))
print(f"扫描到 {len(所有文件)} 个对话文件")
# 获取已存在的文件路径(用于去重)
已有文件路径 = set()
if not full_mode:
for doc in db["对话记录"].find({"来源": "对话归档"}, {"来源文件路径": 1}):
if "来源文件路径" in doc:
已有文件路径.add(doc["来源文件路径"])
print(f"已存在 {len(已有文件路径)} 个对话(将跳过)")
总对话 = 0
新增对话 = 0
跳过对话 = 0
总消息 = 0
项目计数 = defaultdict(int)
错误文件 = []
批量操作_对话 = []
批量操作_消息 = []
批量大小 = 100
for 文件路径 in 所有文件:
总对话 += 1
# 生成相对路径作为唯一标识
相对路径 = str(文件路径.relative_to(ARCHIVE_BASE))
# 检查是否已存在(增量模式)
if not full_mode and 相对路径 in 已有文件路径:
跳过对话 += 1
if 总对话 % 50 == 0:
print(f" 处理进度: {总对话}/{len(所有文件)} (跳过: {跳过对话}, 新增: {新增对话})", end="\r")
continue
# 解析对话文件
消息列表, 首条用户消息, 对话名称 = 解析对话文件(文件路径)
if not 消息列表:
错误文件.append(相对路径)
continue
# 生成唯一对话ID
对话ID = 生成唯一ID(文件路径)
# 检测项目分类
项目 = 检测项目(相对路径, 对话名称, 首条用户消息)
项目计数[项目] += 1
# 获取文件修改时间
try:
文件修改时间 = datetime.fromtimestamp(文件路径.stat().st_mtime, tz=timezone.utc)
except Exception:
文件修改时间 = datetime.now(timezone.utc)
# 构建对话记录
对话文档 = {
"对话ID": 对话ID,
"名称": 对话名称,
"项目": 项目,
"标签": ["对话归档"],
"创建时间": 文件修改时间,
"更新时间": datetime.now(timezone.utc),
"消息数量": len(消息列表),
"是否Agent": True,
"首条消息": 首条用户消息,
"来源": "对话归档",
"来源文件路径": 相对路径, # 用于唯一性检查
"来源完整路径": str(文件路径),
"导入时间": datetime.now(timezone.utc),
}
批量操作_对话.append(
UpdateOne(
{"来源文件路径": 相对路径}, # 使用文件路径作为唯一键
{"$set": 对话文档},
upsert=True,
)
)
# 构建消息内容
for idx, 消息 in enumerate(消息列表):
消息ID = f"msg-{idx + 1}"
消息文档 = {
"对话ID": 对话ID,
"消息ID": 消息ID,
"类型": 1 if 消息["角色"] == "用户" else 2,
"角色": 消息["角色"],
"内容": 消息["内容"][:50000], # 限制长度
"创建时间": 文件修改时间,
"是否Agent": True,
"工具调用数": 0,
"代码块数": 0,
}
批量操作_消息.append(
UpdateOne(
{"对话ID": 对话ID, "消息ID": 消息ID},
{"$set": 消息文档},
upsert=True,
)
)
总消息 += 1
新增对话 += 1
# 批量写入
if len(批量操作_对话) >= 批量大小:
try:
db["对话记录"].bulk_write(批量操作_对话, ordered=False)
except BulkWriteError:
pass
批量操作_对话 = []
if len(批量操作_消息) >= 批量大小:
try:
db["消息内容"].bulk_write(批量操作_消息, ordered=False)
except BulkWriteError:
pass
批量操作_消息 = []
if 总对话 % 50 == 0:
print(f" 处理进度: {总对话}/{len(所有文件)} (跳过: {跳过对话}, 新增: {新增对话})", end="\r")
# 写入剩余数据
if 批量操作_对话:
try:
db["对话记录"].bulk_write(批量操作_对话, ordered=False)
except BulkWriteError:
pass
if 批量操作_消息:
try:
db["消息内容"].bulk_write(批量操作_消息, ordered=False)
except BulkWriteError:
pass
print(f"\n导入完成:")
print(f" 总文件数: {总对话}")
print(f" 新增对话: {新增对话}")
print(f" 跳过对话: {跳过对话}")
print(f" 总消息数: {总消息}")
print(f" 错误文件: {len(错误文件)}")
if 错误文件:
print(f"\n错误文件列表前10个:")
for f in 错误文件[:10]:
print(f" {f}")
# 更新项目分类统计
print("\n项目分布:")
for 项目, 数量 in sorted(项目计数.items(), key=lambda x: -x[1]):
print(f" {项目}: {数量}")
db["项目分类"].update_one(
{"名称": 项目},
{"$set": {"名称": 项目, "更新时间": datetime.now(timezone.utc)}, "$inc": {"对话数": 数量}},
upsert=True,
)
def 打印统计(db):
"""打印 MongoDB 统计信息"""
print(f"\n{'=' * 50}")
print("MongoDB 统计")
print(f"{'=' * 50}")
总对话 = db["对话记录"].count_documents({})
总消息 = db["消息内容"].count_documents({})
归档对话 = db["对话记录"].count_documents({"来源": "对话归档"})
print(f"总对话数: {总对话}")
print(f"总消息数: {总消息}")
print(f"对话归档来源: {归档对话}")
pipeline = [
{"$group": {"_id": "$项目", "数量": {"$sum": 1}}},
{"$sort": {"数量": -1}},
]
print("\n项目分布:")
for doc in db["对话记录"].aggregate(pipeline):
print(f" {doc['_id']}: {doc['数量']}")
def main():
parser = argparse.ArgumentParser(description="对话归档目录导入 MongoDB")
parser.add_argument("--full", action="store_true", help="全量导入(强制覆盖)")
parser.add_argument("--stats", action="store_true", help="仅统计,不导入")
args = parser.parse_args()
print("连接 MongoDB...")
client = MongoClient(MONGO_URI, serverSelectionTimeoutMS=5000)
try:
client.admin.command("ping")
except Exception as e:
print(f"连接失败: {e}")
sys.exit(1)
db = client[DB_NAME]
创建索引(db)
if args.stats:
打印统计(db)
else:
导入对话归档(db, full_mode=args.full)
打印统计(db)
client.close()
print("\n完成!")
if __name__ == "__main__":
main()

View File

@@ -0,0 +1,448 @@
#!/usr/bin/env python3
"""
Cursor 聊天记录迁移到 MongoDB中文字段版
从 state.vscdb (SQLite) + agent-transcripts (JSONL) → MongoDB karuo_site
用法:
python3 migrate_cursor_to_mongo.py # 增量同步
python3 migrate_cursor_to_mongo.py --full # 全量迁移
python3 migrate_cursor_to_mongo.py --include-transcripts # 含 agent-transcripts
"""
import argparse
import json
import os
import sqlite3
import sys
from datetime import datetime, timezone
from pathlib import Path
try:
from pymongo import MongoClient, UpdateOne
from pymongo.errors import BulkWriteError
except ImportError:
print("需要 pymongo: pip install pymongo")
sys.exit(1)
MONGO_URI = "mongodb://admin:admin123@localhost:27017/?authSource=admin"
DB_NAME = "karuo_site"
STATE_VSCDB = os.path.expanduser(
"~/Library/Application Support/Cursor/User/globalStorage/state.vscdb"
)
TRANSCRIPTS_BASE = os.path.expanduser("~/.cursor/projects")
# 精简分类:大类优先,减少碎片(关键词持续优化以降低未分类数量)
项目分类规则 = {
"卡若AI": ["卡若AI", "karuo_ai", "BOOTSTRAP", "SKILL_REGISTRY", "五行", "卡若ai"],
"Soul创业": ["soul", "Soul", "soul创业", "卡若创业派对", "soul派对", "soul运营"],
"存客宝": ["cunkebao", "存客宝", "触客宝", "touchkebao"],
"玩值电竞": ["玩值", "wanzhi", "wanzhi_esports", "wzdj"],
"数据处理": ["数据中台", "datacenter", "KR_", "SG_", "导入mongo", "mongo数据库", "数据库集合", "集合导入", "嘟嘟牛", "社工", "MongoDB迁移", "数据库迁移", "数据库恢复", "数据库优化", "/Users/karuo/数据库"],
"神射手": ["shensheshou", "神射手"],
"上帝之眼": ["上帝之眼", "god_eye", "量化交易"],
"服务器": ["服务器", "宝塔", "nginx", "SSL", "502", "腾讯云"],
"设备管理": ["ADB", "投屏", "scrcpy", "局域网", "远程控制", "192.168"],
"群晖NAS": ["群晖", "Synology", "NAS", "CKBNAS", "nas_init", "1825", "smb://", "NAS部署", "USB连接"],
"飞书": ["飞书", "feishu", "lark", "妙记", "飞书妙记", "智能纪要"],
"微信管理": ["微信", "WeChat", "微信存储", "社群占用"],
"工具维护": ["cursor", "state.vscdb", "icloud", "iCloud", "docker", "Docker", "硬盘", "磁盘", "空间", "node_modules", ".next", "清理", "输入法", "搜狗", "下载目录", "整理下载", "文件分类", "无法安装", "快捷方式", "进程", "快捷键", "GitHub", "Gitea", "fnvtk", "token"],
"个人": ["/个人/", "/1、卡若", "日记", "记忆", "iPhone", "相册", "MacBook相册", "Photos"],
"开发": ["/开发/", "知己", "项目模板", "智能项目生成", "金:项目", "银掌柜", "续茄", "小程序", "腾讯书籍", "分销模块", "前后端整合", "package.json", "开发文档", "开发模板", "MBTI", "route.ts", "page.tsx", "wxml", "wxss"],
}
def 检测项目(文件路径列表: list, 名称: str = "", 内容: str = "") -> str:
搜索文本 = " ".join(文件路径列表) + " " + 名称 + " " + 内容
for 项目, 关键词列表 in 项目分类规则.items():
for 关键词 in 关键词列表:
if 关键词.lower() in 搜索文本.lower():
return 项目
return "未分类"
def 时间戳转时间(ts_ms):
if not ts_ms or ts_ms == 0:
return None
try:
return datetime.fromtimestamp(ts_ms / 1000, tz=timezone.utc)
except (ValueError, OSError):
return None
def 创建索引(db):
对话集 = db["对话记录"]
对话集.create_index("对话ID", unique=True)
对话集.create_index("项目")
对话集.create_index("创建时间")
对话集.create_index([("名称", "text"), ("首条消息", "text")])
消息集 = db["消息内容"]
消息集.create_index([("对话ID", 1), ("消息ID", 1)], unique=True)
消息集.create_index("对话ID")
消息集.create_index("创建时间")
消息集.create_index([("内容", "text")])
db["项目分类"].create_index("名称", unique=True)
print("索引创建完成")
def 迁移对话数据(db, full_mode=False):
if not os.path.exists(STATE_VSCDB):
print(f"未找到 state.vscdb: {STATE_VSCDB}")
return
print(f"\n{'=' * 50}")
print(f"迁移 state.vscdb ({'全量' if full_mode else '增量'})")
大小 = os.path.getsize(STATE_VSCDB) / 1024 / 1024 / 1024
print(f"文件大小: {大小:.1f} GB")
print(f"{'=' * 50}")
conn = sqlite3.connect(STATE_VSCDB)
cursor = conn.cursor()
已有ID = set()
if not full_mode:
已有ID = set(
doc["对话ID"] for doc in db["对话记录"].find({}, {"对话ID": 1})
)
print(f"MongoDB 已有 {len(已有ID)} 个对话")
# 阶段1: 对话元数据
print("\n--- 阶段1: 对话元数据 ---")
cursor.execute("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'")
对话操作 = []
对话消息映射 = {}
项目计数 = {}
跳过数 = 0
for row in cursor.fetchall():
key, value = row
对话ID = key.replace("composerData:", "")
if not full_mode and 对话ID in 已有ID:
跳过数 += 1
continue
try:
data = json.loads(value)
except (json.JSONDecodeError, TypeError):
continue
headers = data.get("fullConversationHeadersOnly", [])
if not headers:
continue
消息ID列表 = [h.get("bubbleId", "") for h in headers if h.get("bubbleId")]
对话消息映射[对话ID] = 消息ID列表
ctx = data.get("context", {})
文件路径 = []
for f in ctx.get("fileSelections", []):
path = f.get("uri", {}).get("fsPath", "")
if path:
文件路径.append(path)
for f in ctx.get("folderSelections", []):
if isinstance(f, dict):
path = f.get("uri", {}).get("fsPath", "")
if path:
文件路径.append(path)
名称 = data.get("name", "") or ""
副标题 = data.get("subtitle", "") or ""
项目 = 检测项目(文件路径, 名称, 副标题)
项目计数[项目] = 项目计数.get(项目, 0) + 1
创建时间 = 时间戳转时间(data.get("createdAt"))
更新时间 = 时间戳转时间(data.get("lastUpdatedAt"))
对话文档 = {
"对话ID": 对话ID,
"名称": 名称,
"副标题": 副标题,
"项目": 项目,
"标签": [],
"创建时间": 创建时间,
"更新时间": 更新时间,
"消息数量": len(headers),
"是否Agent": data.get("isAgentic", False),
"模型配置": data.get("modelConfig", {}),
"关联文件": 文件路径[:50],
"首条消息": "",
"来源": "state.vscdb",
"来源工作区": "",
"迁移时间": datetime.now(timezone.utc),
}
对话操作.append(
UpdateOne({"对话ID": 对话ID}, {"$set": 对话文档}, upsert=True)
)
if 对话操作:
try:
result = db["对话记录"].bulk_write(对话操作, ordered=False)
print(f"插入 {result.upserted_count}, 更新 {result.modified_count}, 跳过 {跳过数}")
except BulkWriteError as e:
print(f"部分写入: {e.details.get('nInserted', 0)} 成功")
else:
print(f"无新对话 (跳过 {跳过数})")
# 阶段2: 消息内容
print("\n--- 阶段2: 消息内容 ---")
已有消息对话 = set()
if not full_mode:
pipeline = [{"$group": {"_id": "$对话ID"}}]
已有消息对话 = set(doc["_id"] for doc in db["消息内容"].aggregate(pipeline))
总消息 = 0
批量操作 = []
批量大小 = 2000
for 对话ID, 消息ID列表 in 对话消息映射.items():
if not full_mode and 对话ID in 已有消息对话:
continue
首条用户消息 = ""
for mid in 消息ID列表:
key = f"bubbleId:{对话ID}:{mid}"
cursor.execute("SELECT value FROM cursorDiskKV WHERE key = ?", (key,))
row = cursor.fetchone()
if not row:
continue
try:
data = json.loads(row[0])
except (json.JSONDecodeError, TypeError):
continue
类型 = data.get("type", 0)
内容 = data.get("text", "") or ""
timing = data.get("timingInfo", {})
rpc_time = timing.get("clientRpcSendTime")
创建时间 = 时间戳转时间(rpc_time) if rpc_time else None
if 类型 == 1 and not 首条用户消息 and 内容:
首条用户消息 = 内容[:500]
工具调用 = data.get("toolResults", [])
代码块 = data.get("codeBlocks", [])
消息文档 = {
"对话ID": 对话ID,
"消息ID": mid,
"类型": 类型,
"角色": "用户" if 类型 == 1 else "AI",
"内容": 内容,
"创建时间": 创建时间,
"是否Agent": data.get("isAgentic", False),
"Token用量": data.get("tokenCount", {}),
"工具调用数": len(工具调用) if 工具调用 else 0,
"代码块数": len(代码块) if 代码块 else 0,
}
批量操作.append(
UpdateOne(
{"对话ID": 对话ID, "消息ID": mid},
{"$set": 消息文档},
upsert=True,
)
)
总消息 += 1
if len(批量操作) >= 批量大小:
try:
db["消息内容"].bulk_write(批量操作, ordered=False)
except BulkWriteError:
pass
批量操作 = []
print(f" 已处理 {总消息} 条消息...", end="\r")
if 首条用户消息:
db["对话记录"].update_one(
{"对话ID": 对话ID}, {"$set": {"首条消息": 首条用户消息}}
)
if 批量操作:
try:
db["消息内容"].bulk_write(批量操作, ordered=False)
except BulkWriteError:
pass
print(f"\n消息迁移完成: {总消息}")
# 阶段3: 项目分类
print("\n--- 阶段3: 项目分类 ---")
for 项目, 数量 in 项目计数.items():
db["项目分类"].update_one(
{"名称": 项目},
{"$set": {"名称": 项目, "更新时间": datetime.now(timezone.utc)}, "$inc": {"对话数": 数量}},
upsert=True,
)
for p, c in sorted(项目计数.items(), key=lambda x: -x[1]):
print(f" {p}: {c}")
conn.close()
def 迁移Transcripts(db):
print(f"\n{'=' * 50}")
print("迁移 agent-transcripts")
print(f"{'=' * 50}")
if not os.path.exists(TRANSCRIPTS_BASE):
print(f"目录不存在: {TRANSCRIPTS_BASE}")
return
已有ID = set(
doc["对话ID"]
for doc in db["对话记录"].find({"来源": "agent-transcript"}, {"对话ID": 1})
)
总文件 = 0
新增 = 0
for workspace_dir in Path(TRANSCRIPTS_BASE).iterdir():
if not workspace_dir.is_dir():
continue
transcripts_dir = workspace_dir / "agent-transcripts"
if not transcripts_dir.exists():
continue
工作区 = workspace_dir.name.replace("Users-karuo-Documents-", "")
for chat_dir in transcripts_dir.iterdir():
if not chat_dir.is_dir() or chat_dir.name == "subagents":
continue
main_jsonl = chat_dir / f"{chat_dir.name}.jsonl"
if not main_jsonl.exists():
continue
tid = chat_dir.name
if tid in 已有ID:
continue
总文件 += 1
try:
消息列表 = []
首条 = ""
对话名 = ""
with open(main_jsonl, "r", encoding="utf-8") as f:
for line in f:
line = line.strip()
if not line:
continue
try:
entry = json.loads(line)
except json.JSONDecodeError:
continue
role = entry.get("role", "")
content = entry.get("content", "")
if isinstance(content, list):
parts = [p.get("text", "") for p in content if isinstance(p, dict) and p.get("type") == "text"]
content = "\n".join(parts)
if not isinstance(content, str):
content = str(content)
if role == "user" and not 首条 and content:
首条 = content[:500]
对话名 = " ".join(content[:100].split()[:8])
消息列表.append({
"对话ID": tid,
"消息ID": f"t-{len(消息列表)}",
"类型": 1 if role == "user" else 2,
"角色": "用户" if role == "user" else "AI",
"内容": content[:50000],
"创建时间": datetime.now(timezone.utc),
"是否Agent": True,
"Token用量": {},
"工具调用数": 0,
"代码块数": 0,
})
if not 消息列表:
continue
项目 = 检测项目([], 对话名, 首条)
db["对话记录"].update_one(
{"对话ID": tid},
{"$set": {
"对话ID": tid,
"名称": 对话名 or f"Transcript {tid[:8]}",
"副标题": "",
"项目": 项目,
"标签": ["agent-transcript"],
"创建时间": datetime.now(timezone.utc),
"更新时间": datetime.now(timezone.utc),
"消息数量": len(消息列表),
"是否Agent": True,
"模型配置": {},
"关联文件": [],
"首条消息": 首条,
"来源": "agent-transcript",
"来源工作区": 工作区,
"迁移时间": datetime.now(timezone.utc),
}},
upsert=True,
)
ops = [
UpdateOne({"对话ID": m["对话ID"], "消息ID": m["消息ID"]}, {"$set": m}, upsert=True)
for m in 消息列表
]
try:
db["消息内容"].bulk_write(ops, ordered=False)
except BulkWriteError:
pass
新增 += 1
except Exception as e:
print(f" 处理 {tid} 失败: {e}")
print(f"扫描 {总文件} 个, 新增 {新增}")
def 打印统计(db):
print(f"\n{'=' * 50}")
print("迁移统计")
print(f"{'=' * 50}")
对话数 = db["对话记录"].count_documents({})
消息数 = db["消息内容"].count_documents({})
print(f"总对话: {对话数}")
print(f"总消息: {消息数}")
pipeline = [
{"$group": {"_id": "$项目", "数量": {"$sum": 1}}},
{"$sort": {"数量": -1}},
]
print("\n项目分布:")
for doc in db["对话记录"].aggregate(pipeline):
print(f" {doc['_id']}: {doc['数量']}")
def main():
parser = argparse.ArgumentParser(description="Cursor 聊天记录迁移")
parser.add_argument("--full", action="store_true", help="全量迁移")
parser.add_argument("--include-transcripts", action="store_true", help="含 agent-transcripts")
args = parser.parse_args()
print("连接 MongoDB...")
client = MongoClient(MONGO_URI, serverSelectionTimeoutMS=5000)
try:
client.admin.command("ping")
except Exception as e:
print(f"连接失败: {e}")
sys.exit(1)
db = client[DB_NAME]
创建索引(db)
迁移对话数据(db, full_mode=args.full)
if args.include_transcripts:
迁移Transcripts(db)
打印统计(db)
client.close()
if __name__ == "__main__":
main()

View File

@@ -0,0 +1,265 @@
#!/usr/bin/env python3
"""
Cursor 聊天记录查询(中文字段版)
用法:
python3 query_chat_history.py --stats
python3 query_chat_history.py --search "关键词"
python3 query_chat_history.py --project "Soul创业"
python3 query_chat_history.py --since 2026-03-01
python3 query_chat_history.py --conversation <对话ID>
python3 query_chat_history.py --list
python3 query_chat_history.py --reclassify
python3 query_chat_history.py --tag <对话ID> "标签"
"""
import argparse
import sys
from datetime import datetime, timezone
try:
from pymongo import MongoClient
except ImportError:
print("需要 pymongo: pip install pymongo")
sys.exit(1)
MONGO_URI = "mongodb://admin:admin123@localhost:27017/?authSource=admin"
DB_NAME = "karuo_site"
项目分类规则 = {
"卡若AI": ["卡若AI", "karuo_ai", "BOOTSTRAP", "SKILL_REGISTRY", "五行", "卡若ai"],
"Soul创业": ["soul", "Soul", "soul创业", "卡若创业派对", "soul派对", "soul运营"],
"存客宝": ["cunkebao", "存客宝", "触客宝", "touchkebao"],
"玩值电竞": ["玩值", "wanzhi", "wanzhi_esports", "wzdj"],
"数据处理": ["数据中台", "datacenter", "KR_", "SG_", "导入mongo", "mongo数据库", "数据库集合", "集合导入", "嘟嘟牛", "社工", "MongoDB迁移", "数据库迁移", "数据库恢复", "数据库优化", "/Users/karuo/数据库"],
"神射手": ["shensheshou", "神射手"],
"上帝之眼": ["上帝之眼", "god_eye", "量化交易"],
"服务器": ["服务器", "宝塔", "nginx", "SSL", "502", "腾讯云"],
"设备管理": ["ADB", "投屏", "scrcpy", "局域网", "远程控制", "192.168"],
"群晖NAS": ["群晖", "Synology", "NAS", "CKBNAS", "nas_init", "1825", "smb://", "NAS部署", "USB连接"],
"飞书": ["飞书", "feishu", "lark", "妙记", "飞书妙记", "智能纪要"],
"微信管理": ["微信", "WeChat", "微信存储", "社群占用"],
"工具维护": ["cursor", "state.vscdb", "icloud", "iCloud", "docker", "Docker", "硬盘", "磁盘", "空间", "node_modules", ".next", "清理", "输入法", "搜狗", "下载目录", "整理下载", "文件分类", "无法安装", "快捷方式", "进程", "快捷键", "GitHub", "Gitea", "fnvtk", "token"],
"个人": ["/个人/", "/1、卡若", "日记", "记忆", "iPhone", "相册", "MacBook相册", "Photos"],
"开发": ["/开发/", "知己", "项目模板", "智能项目生成", "金:项目", "银掌柜", "续茄", "小程序", "腾讯书籍", "分销模块", "前后端整合", "package.json", "开发文档", "开发模板", "MBTI", "route.ts", "page.tsx", "wxml", "wxss"],
}
def 检测项目(文件路径, 名称="", 内容=""):
搜索文本 = " ".join(文件路径) + " " + 名称 + " " + 内容
for 项目, 关键词 in 项目分类规则.items():
for kw in 关键词:
if kw.lower() in 搜索文本.lower():
return 项目
return "未分类"
def get_db():
client = MongoClient(MONGO_URI, serverSelectionTimeoutMS=5000)
try:
client.admin.command("ping")
except Exception as e:
print(f"MongoDB 连接失败: {e}")
sys.exit(1)
return client, client[DB_NAME]
def 查看统计(db):
对话数 = db["对话记录"].count_documents({})
消息数 = db["消息内容"].count_documents({})
print(f"{'=' * 55}")
print(f" 聊天记录统计")
print(f"{'=' * 55}")
print(f" 总对话: {对话数}")
print(f" 总消息: {消息数}")
pipeline = [
{"$group": {"_id": "$项目", "数量": {"$sum": 1}, "消息": {"$sum": "$消息数量"}}},
{"$sort": {"数量": -1}},
]
print(f"\n {'项目':<15} {'对话':>6} {'消息':>8}")
print(f" {'-' * 35}")
for doc in db["对话记录"].aggregate(pipeline):
print(f" {doc['_id']:<15} {doc['数量']:>6} {doc['消息']:>8}")
p来源 = [{"$group": {"_id": "$来源", "数量": {"$sum": 1}}}]
print(f"\n 来源:")
for doc in db["对话记录"].aggregate(p来源):
print(f" {doc['_id']}: {doc['数量']}")
p月份 = [
{"$group": {"_id": {"$dateToString": {"format": "%Y-%m", "date": "$创建时间"}}, "数量": {"$sum": 1}}},
{"$sort": {"_id": -1}}, {"$limit": 6},
]
print(f"\n 月份分布:")
for doc in db["对话记录"].aggregate(p月份):
if doc["_id"]:
print(f" {doc['_id']}: {doc['数量']}")
print(f"{'=' * 55}")
def 搜索对话(db, 关键词, limit=20):
print(f"\n搜索: \"{关键词}\"")
结果 = db["消息内容"].find(
{"$text": {"$search": 关键词}},
{"score": {"$meta": "textScore"}},
).sort([("score", {"$meta": "textScore"})]).limit(limit * 2)
对话集 = set()
摘要 = {}
for msg in 结果:
cid = msg["对话ID"]
对话集.add(cid)
if cid not in 摘要:
摘要[cid] = msg.get("内容", "")[:200]
if not 对话集:
r2 = db["对话记录"].find(
{"$text": {"$search": 关键词}},
{"score": {"$meta": "textScore"}},
).sort([("score", {"$meta": "textScore"})]).limit(limit)
for conv in r2:
对话集.add(conv["对话ID"])
if not 对话集:
print("未找到匹配")
return
convs = db["对话记录"].find({"对话ID": {"$in": list(对话集)}}).limit(limit)
print(f"\n找到 {len(对话集)} 个相关对话:\n")
for conv in convs:
cid = conv["对话ID"]
名称 = conv.get("名称", "无标题")
项目 = conv.get("项目", "未分类")
时间 = conv.get("创建时间")
时间str = 时间.strftime("%Y-%m-%d %H:%M") if 时间 else "未知"
数量 = conv.get("消息数量", 0)
s = 摘要.get(cid, conv.get("首条消息", ""))[:150]
print(f" [{项目}] {名称}")
print(f" ID: {cid}")
print(f" 时间: {时间str} | 消息: {数量}")
if s:
print(f" 摘要: {s}...")
print()
def 列出对话(db, project=None, since=None, limit=50):
query = {}
if project:
query["项目"] = {"$regex": project, "$options": "i"}
if since:
try:
dt = datetime.strptime(since, "%Y-%m-%d").replace(tzinfo=timezone.utc)
query["创建时间"] = {"$gte": dt}
except ValueError:
print(f"日期格式错误: {since}")
return
convs = db["对话记录"].find(query).sort("创建时间", -1).limit(limit)
count = 0
for conv in convs:
名称 = conv.get("名称", "无标题")
项目 = conv.get("项目", "未分类")
时间 = conv.get("创建时间")
时间str = 时间.strftime("%Y-%m-%d %H:%M") if 时间 else "未知"
数量 = conv.get("消息数量", 0)
ag = "🤖" if conv.get("是否Agent") else "💬"
标签 = ", ".join(conv.get("标签", []))
print(f" {ag} [{项目}] {名称}")
print(f" ID: {conv['对话ID']}")
print(f" 时间: {时间str} | 消息: {数量}{' | 标签: ' + 标签 if 标签 else ''}")
print()
count += 1
print(f"{count} 个对话")
def 查看对话(db, 对话ID):
conv = db["对话记录"].find_one({"对话ID": 对话ID})
if not conv:
print(f"未找到: {对话ID}")
return
print(f"\n{'=' * 55}")
print(f" 对话: {conv.get('名称', '无标题')}")
print(f" 项目: {conv.get('项目', '未分类')}")
时间 = conv.get("创建时间")
if 时间:
print(f" 时间: {时间.strftime('%Y-%m-%d %H:%M')}")
print(f" 消息: {conv.get('消息数量', 0)}")
标签 = conv.get("标签", [])
if 标签:
print(f" 标签: {', '.join(标签)}")
print(f"{'=' * 55}\n")
msgs = db["消息内容"].find({"对话ID": 对话ID}).sort("_id", 1)
for msg in msgs:
角色 = "👤 用户" if msg.get("类型") == 1 else "🤖 AI"
内容 = msg.get("内容", "")
t = msg.get("创建时间")
ts = t.strftime("%H:%M:%S") if t else ""
print(f"--- {角色} {ts} ---")
if 内容:
print(内容[:2000] if len(内容) > 2000 else 内容)
else:
print("(无内容)")
print()
def 重新分类(db):
print("重新分类所有对话...")
updated = 0
for conv in db["对话记录"].find({}):
new_p = 检测项目(
conv.get("关联文件", []),
conv.get("名称", ""),
conv.get("首条消息", "") + " " + conv.get("副标题", ""),
)
if new_p != conv.get("项目"):
db["对话记录"].update_one({"_id": conv["_id"]}, {"$set": {"项目": new_p}})
updated += 1
print(f"更新 {updated} 个对话")
def 打标签(db, 对话ID, 标签):
result = db["对话记录"].update_one({"对话ID": 对话ID}, {"$addToSet": {"标签": 标签}})
print(f"{'已添加' if result.modified_count else '未变更'}: \"{标签}\"{对话ID}")
def main():
parser = argparse.ArgumentParser(description="聊天记录查询")
parser.add_argument("--stats", action="store_true")
parser.add_argument("--search", type=str)
parser.add_argument("--project", type=str)
parser.add_argument("--since", type=str)
parser.add_argument("--list", action="store_true")
parser.add_argument("--conversation", type=str)
parser.add_argument("--reclassify", action="store_true")
parser.add_argument("--tag", nargs=2, metavar=("ID", "TAG"))
parser.add_argument("--limit", type=int, default=50)
args = parser.parse_args()
client, db = get_db()
if args.stats:
查看统计(db)
elif args.search:
搜索对话(db, args.search, args.limit)
elif args.list:
列出对话(db, args.project, args.since, args.limit)
elif args.conversation:
查看对话(db, args.conversation)
elif args.reclassify:
重新分类(db)
elif args.tag:
打标签(db, args.tag[0], args.tag[1])
elif args.project or args.since:
列出对话(db, args.project, args.since, args.limit)
else:
parser.print_help()
client.close()
if __name__ == "__main__":
main()

View File

@@ -0,0 +1,436 @@
#!/usr/bin/env python3
"""
实时对话同步与优化迭代
每次对话结束时自动调用将对话实时写入MongoDB并进行优化迭代
功能:
1. 实时写入对话结束时立即写入MongoDB
2. 自动优化:项目分类、标签提取、摘要生成
3. 迭代改进:基于历史数据优化分类规则
用法由卡若AI自动调用:
python3 realtime_chat_sync.py --current-conversation-id <对话ID>
python3 realtime_chat_sync.py --optimize-classification # 优化分类规则
python3 realtime_chat_sync.py --stats # 查看统计
"""
import argparse
import json
import os
import sqlite3
import sys
from datetime import datetime, timezone
from pathlib import Path
from typing import Dict, List, Optional
# 保证从任意目录运行都能找到 chat_fallback
_script_dir = Path(__file__).resolve().parent
if str(_script_dir) not in sys.path:
sys.path.insert(0, str(_script_dir))
try:
from pymongo import MongoClient, UpdateOne
from pymongo.errors import BulkWriteError, ServerSelectionTimeoutError
except ImportError:
print("需要 pymongo: pip install pymongo")
sys.exit(1)
import chat_fallback as _fallback
MONGO_URI = "mongodb://admin:admin123@localhost:27017/?authSource=admin"
DB_NAME = "karuo_site"
STATE_VSCDB = os.path.expanduser(
"~/Library/Application Support/Cursor/User/globalStorage/state.vscdb"
)
# 项目分类规则从auto_archive.py继承并扩展
项目分类规则 = {
"卡若AI": ["卡若AI", "karuo_ai", "BOOTSTRAP", "SKILL_REGISTRY", "五行", "卡若ai", "运营中枢", "技能", "SKILL.md"],
"Soul创业": ["soul", "Soul", "soul创业", "卡若创业派对", "soul派对", "soul运营", "派对运营"],
"存客宝": ["cunkebao", "存客宝", "触客宝", "touchkebao"],
"玩值电竞": ["玩值", "wanzhi", "wanzhi_esports", "wzdj"],
"数据处理": ["数据中台", "datacenter", "KR_", "SG_", "导入mongo", "mongo数据库", "集合导入", "嘟嘟牛", "社工", "MongoDB迁移", "数据库迁移", "数据库恢复", "数据库优化", "/Users/karuo/数据库"],
"神射手": ["shensheshou", "神射手"],
"上帝之眼": ["上帝之眼", "god_eye", "量化交易"],
"服务器": ["服务器", "宝塔", "nginx", "SSL", "502", "腾讯云", "部署", "docker", "Docker"],
"设备管理": ["ADB", "投屏", "scrcpy", "局域网", "远程控制", "192.168"],
"群晖NAS": ["群晖", "Synology", "NAS", "CKBNAS", "nas_init", "1825", "smb://", "NAS部署", "USB连接"],
"飞书": ["飞书", "feishu", "lark", "妙记", "飞书妙记", "智能纪要", "飞书日志"],
"微信管理": ["微信", "WeChat", "微信存储", "社群占用"],
"工具维护": ["cursor", "state.vscdb", "icloud", "docker", "Docker", "硬盘", "磁盘", "空间", "node_modules", ".next", "清理", "输入法", "搜狗", "下载目录", "整理下载", "文件分类", "无法安装", "快捷方式", "进程", "快捷键", "GitHub", "Gitea", "fnvtk", "token"],
"个人": ["/个人/", "/1、卡若", "日记", "记忆", "iPhone", "相册", "MacBook相册", "Photos"],
"开发": ["/开发/", "知己", "项目模板", "智能项目生成", "金:项目", "银掌柜", "续茄", "小程序", "腾讯书籍", "分销模块", "前后端整合", "package.json", "开发文档", "开发模板", "MBTI", "route.ts", "page.tsx", "wxml", "wxss"],
}
def 检测项目(文件路径: List[str], 名称: str = "", 内容: str = "") -> str:
"""智能项目分类(支持多关键词匹配和权重计算)"""
搜索文本 = " ".join(文件路径) + " " + 名称 + " " + 内容
搜索文本_lower = 搜索文本.lower()
项目得分 = {}
for 项目, 关键词列表 in 项目分类规则.items():
得分 = 0
for kw in 关键词列表:
if kw.lower() in 搜索文本_lower:
# 文件名匹配权重更高
if any(kw.lower() in p.lower() for p in 文件路径):
得分 += 3
# 名称匹配权重中等
elif kw.lower() in 名称.lower():
得分 += 2
# 内容匹配权重较低
else:
得分 += 1
项目得分[项目] = 得分
if 项目得分:
# 返回得分最高的项目
最高项目 = max(项目得分.items(), key=lambda x: x[1])
if 最高项目[1] > 0:
return 最高项目[0]
return "未分类"
def 提取标签(内容: str, 项目: str) -> List[str]:
"""从对话内容中提取标签"""
标签 = []
# 基于项目的标签
if 项目 != "未分类":
标签.append(项目)
# 关键词标签
关键词标签 = {
"bug修复": ["bug", "错误", "修复", "问题", "报错"],
"功能开发": ["开发", "实现", "功能", "新增"],
"优化": ["优化", "改进", "提升", "性能"],
"部署": ["部署", "上线", "发布", "docker"],
"数据分析": ["数据", "分析", "统计", "报表"],
"文档": ["文档", "说明", "手册", "README"],
}
for 标签名, 关键词列表 in 关键词标签.items():
if any(kw in 内容 for kw in 关键词列表):
标签.append(标签名)
return list(set(标签)) # 去重
def 生成摘要(消息列表: List[Dict]) -> str:
"""生成对话摘要"""
if not 消息列表:
return ""
# 提取用户前3条消息的关键信息
用户消息 = [m.get("内容", "") for m in 消息列表 if m.get("角色") == "用户"][:3]
摘要 = " | ".join([msg[:100] for msg in 用户消息 if msg])
if len(摘要) > 300:
摘要 = 摘要[:300] + "..."
return 摘要
def 时间戳转时间(ts_ms):
"""时间戳转datetime"""
if not ts_ms:
return None
try:
return datetime.fromtimestamp(ts_ms / 1000, tz=timezone.utc)
except (ValueError, OSError):
return None
def 实时同步对话(对话ID: str, 强制: bool = False) -> Optional[Dict]:
"""
实时同步指定对话到MongoDB
Args:
对话ID: Cursor对话ID
强制: 是否强制更新(即使已存在)
Returns:
对话文档或None
"""
if not os.path.exists(STATE_VSCDB):
print(f"⚠️ state.vscdb 不存在: {STATE_VSCDB}")
return None
# 连接MongoDB
try:
client = MongoClient(MONGO_URI, serverSelectionTimeoutMS=5000)
client.admin.command("ping")
db = client[DB_NAME]
except (ServerSelectionTimeoutError, Exception) as e:
print(f"⚠️ MongoDB 连接失败: {e}")
return None
# 检查是否已存在
if not 强制:
已有 = db["对话记录"].find_one({"对话ID": 对话ID})
if 已有:
print(f"✅ 对话已存在: {对话ID[:8]}...")
return 已有
# 从state.vscdb读取对话数据
conn = sqlite3.connect(STATE_VSCDB)
cursor = conn.cursor()
try:
cursor.execute("SELECT value FROM cursorDiskKV WHERE key = ?", (f"composerData:{对话ID}",))
row = cursor.fetchone()
if not row:
print(f"⚠️ 对话不存在于state.vscdb: {对话ID[:8]}...")
return None
data = json.loads(row[0])
except (json.JSONDecodeError, TypeError) as e:
print(f"⚠️ 解析对话数据失败: {e}")
return None
finally:
conn.close()
# 提取对话信息
headers = data.get("fullConversationHeadersOnly", [])
if not headers:
print(f"⚠️ 对话无消息: {对话ID[:8]}...")
return None
ctx = data.get("context", {})
文件路径 = [f.get("uri", {}).get("fsPath", "") for f in ctx.get("fileSelections", []) if f.get("uri", {}).get("fsPath")]
名称 = data.get("name", "") or ""
副标题 = data.get("subtitle", "") or ""
# 提取消息内容用于分类和摘要
消息内容列表 = []
消息ID列表 = [h.get("bubbleId", "") for h in headers if h.get("bubbleId")]
首条 = ""
# 重新连接读取消息详情
conn = sqlite3.connect(STATE_VSCDB)
cursor = conn.cursor()
for mid in 消息ID列表:
cursor.execute("SELECT value FROM cursorDiskKV WHERE key = ?", (f"bubbleId:{对话ID}:{mid}",))
r = cursor.fetchone()
if not r:
continue
try:
mdata = json.loads(r[0])
except:
continue
类型 = mdata.get("type", 0)
内容 = mdata.get("text", "") or ""
角色 = "用户" if 类型 == 1 else "AI"
if 类型 == 1 and not 首条 and 内容:
首条 = 内容[:500]
消息内容列表.append({
"角色": 角色,
"内容": 内容,
})
conn.close()
# 智能分类和优化
所有内容 = " ".join([m.get("内容", "") for m in 消息内容列表[:10]])
项目 = 检测项目(文件路径, 名称, 所有内容)
标签 = 提取标签(所有内容, 项目)
摘要 = 生成摘要(消息内容列表)
now = datetime.now(timezone.utc)
# 构建对话文档
对话文档 = {
"对话ID": 对话ID,
"名称": 名称 or f"对话 {对话ID[:8]}",
"副标题": 副标题 or 摘要[:200],
"项目": 项目,
"标签": 标签,
"创建时间": 时间戳转时间(data.get("createdAt")) or now,
"更新时间": now,
"消息数量": len(headers),
"是否Agent": data.get("isAgentic", False),
"模型配置": data.get("modelConfig", {}),
"关联文件": 文件路径[:50],
"首条消息": 首条,
"来源": "实时同步",
"来源工作区": "",
"迁移时间": now,
"同步版本": "2.0", # 标记为实时同步版本
}
# 写入MongoDB
try:
db["对话记录"].update_one(
{"对话ID": 对话ID},
{"$set": 对话文档},
upsert=True
)
# 写入消息内容
消息ops = []
for i, mid in enumerate(消息ID列表):
conn = sqlite3.connect(STATE_VSCDB)
cursor = conn.cursor()
cursor.execute("SELECT value FROM cursorDiskKV WHERE key = ?", (f"bubbleId:{对话ID}:{mid}",))
r = cursor.fetchone()
conn.close()
if not r:
continue
try:
mdata = json.loads(r[0])
except:
continue
类型 = mdata.get("type", 0)
内容 = mdata.get("text", "") or ""
timing = mdata.get("timingInfo", {})
创建时间 = 时间戳转时间(timing.get("clientRpcSendTime")) if timing.get("clientRpcSendTime") else now
消息ops.append(UpdateOne(
{"对话ID": 对话ID, "消息ID": mid},
{"$set": {
"对话ID": 对话ID,
"消息ID": mid,
"类型": 类型,
"角色": "用户" if 类型 == 1 else "AI",
"内容": 内容,
"创建时间": 创建时间,
"是否Agent": mdata.get("isAgentic", False),
"Token用量": mdata.get("tokenCount", {}),
"工具调用数": len(mdata.get("toolResults", []) or []),
"代码块数": len(mdata.get("codeBlocks", []) or []),
}},
upsert=True,
))
if 消息ops:
try:
db["消息内容"].bulk_write(消息ops, ordered=False)
except BulkWriteError:
pass
# 同步到fallback
try:
_fallback.追加一条(对话文档)
except Exception:
pass
print(f"✅ 实时同步完成: [{项目}] {名称 or 对话ID[:8]} ({len(headers)} 条消息, {len(标签)} 个标签)")
return 对话文档
except Exception as e:
print(f"❌ 写入MongoDB失败: {e}")
return None
finally:
client.close()
def 优化分类规则(db):
"""基于历史数据优化分类规则"""
print("🔄 开始优化分类规则...")
# 统计未分类对话的关键词
未分类对话 = list(db["对话记录"].find({"项目": "未分类"}, {"名称": 1, "首条消息": 1, "关联文件": 1}).limit(100))
if not 未分类对话:
print("✅ 无未分类对话,分类规则良好")
return
关键词统计 = {}
for 对话 in 未分类对话:
文本 = f"{对话.get('名称', '')} {对话.get('首条消息', '')} {' '.join(对话.get('关联文件', []))}"
# 简单提取关键词实际可以用更复杂的NLP
words = 文本.lower().split()
for word in words:
if len(word) > 3: # 忽略太短的词
关键词统计[word] = 关键词统计.get(word, 0) + 1
# 输出高频关键词建议
if 关键词统计:
高频词 = sorted(关键词统计.items(), key=lambda x: x[1], reverse=True)[:10]
print("📊 未分类对话高频关键词(建议加入分类规则):")
for , 频次 in 高频词:
print(f" - {}: {频次}")
print("✅ 分类规则优化完成")
def 显示统计(db):
"""显示同步统计"""
try:
总数 = db["对话记录"].count_documents({})
实时同步数 = db["对话记录"].count_documents({"来源": "实时同步"})
项目统计 = {}
for 对话 in db["对话记录"].find({}, {"项目": 1}):
项目 = 对话.get("项目", "未知")
项目统计[项目] = 项目统计.get(项目, 0) + 1
print(f"\n📊 对话同步统计")
print(f"总对话数: {总数}")
print(f"实时同步数: {实时同步数}")
print(f"\n📁 项目分布:")
for 项目, 数量 in sorted(项目统计.items(), key=lambda x: x[1], reverse=True):
print(f" {项目}: {数量}")
except Exception as e:
print(f"❌ 统计失败: {e}")
def main():
parser = argparse.ArgumentParser(description="实时对话同步与优化迭代")
parser.add_argument("--current-conversation-id", type=str, help="当前对话ID从Cursor获取")
parser.add_argument("--optimize-classification", action="store_true", help="优化分类规则")
parser.add_argument("--stats", action="store_true", help="显示统计")
parser.add_argument("--force", action="store_true", help="强制更新已存在的对话")
args = parser.parse_args()
# 连接MongoDB
try:
client = MongoClient(MONGO_URI, serverSelectionTimeoutMS=5000)
client.admin.command("ping")
db = client[DB_NAME]
except (ServerSelectionTimeoutError, Exception) as e:
print(f"❌ MongoDB 连接失败: {e}")
sys.exit(1)
if args.stats:
显示统计(db)
elif args.optimize_classification:
优化分类规则(db)
elif args.current_conversation_id:
实时同步对话(args.current_conversation_id, 强制=args.force)
else:
# 默认:扫描最新对话并同步
print("🔄 扫描最新对话...")
if not os.path.exists(STATE_VSCDB):
print(f"⚠️ state.vscdb 不存在")
sys.exit(1)
conn = sqlite3.connect(STATE_VSCDB)
cursor = conn.cursor()
cursor.execute("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%' ORDER BY value DESC LIMIT 1")
row = cursor.fetchone()
conn.close()
if row:
key, value = row
对话ID = key.replace("composerData:", "")
print(f"📝 找到最新对话: {对话ID[:8]}...")
实时同步对话(对话ID, 强制=args.force)
else:
print("⚠️ 未找到对话")
client.close()
if __name__ == "__main__":
main()

View File

@@ -24,6 +24,17 @@ python qq_mail_fetch.py --limit 50
python qq_mail_fetch.py --days 7 --limit 20
```
## Boss 直聘简历附件批量下载
将邮箱中「Boss直聘」相关邮件的所有附件简历等下载到本机「下载」目录下的 `Boss直聘简历` 文件夹:
```bash
python3 download_boss_zhipin_resumes.py # 全部
python3 download_boss_zhipin_resumes.py --days 365 # 仅最近一年(更快)
```
会扫描收件箱 + 垃圾箱,筛选主题/发件人含「Boss」「直聘」「zhipin」「博聘」的邮件输出到 `~/Downloads/Boss直聘简历/`
## 登录失败排查
若出现 `Login fail`,请检查:

View File

@@ -0,0 +1,169 @@
#!/usr/bin/env python3
"""
从 QQ 邮箱中筛选「Boss直聘」相关邮件下载所有附件简历等到下载目录。
依赖:同目录 .qq_mail_envQQ_MAIL、QQ_MAIL_AUTH_CODE
用法python3 download_boss_zhipin_resumes.py [--days 365]
"""
import imaplib
import email
import argparse
import os
import re
import sys
from datetime import datetime, timedelta
from email.header import decode_header
from pathlib import Path
# 复用 qq_mail_fetch 的环境加载
def _load_env():
env_file = Path(__file__).resolve().parent / ".qq_mail_env"
if env_file.exists():
for line in env_file.read_text(encoding="utf-8").splitlines():
line = line.strip()
if line and not line.startswith("#") and "=" in line:
k, v = line.split("=", 1)
os.environ.setdefault(k.strip(), v.strip())
_load_env()
IMAP_HOST = "imap.qq.com"
IMAP_PORT = 993
EMAIL = os.environ.get("QQ_MAIL", "zhengzhiqun@qq.com")
AUTH_CODE = os.environ.get("QQ_MAIL_AUTH_CODE", "")
# 下载目录:用户下载目录下的子文件夹
DOWN_DIR = Path.home() / "Downloads" / "Boss直聘简历"
def _decode_mime(s):
if not s:
return ""
if isinstance(s, bytes):
s = s.decode("utf-8", errors="replace")
s = s.strip()
# 统一用 decode_header 解析(支持 =?UTF-8?B?xxx?= 等)
try:
parts = decode_header(s)
except Exception:
return re.sub(r'[<>:"/\\|?*]', "_", s)
out = []
for part, enc in parts:
if isinstance(part, bytes):
out.append(part.decode(enc or "utf-8", errors="replace"))
else:
out.append(str(part) if part else "")
return "".join(out)
def _is_boss_zhipin_email(subject: str, from_addr: str) -> bool:
"""判断是否为 Boss 直聘相关邮件(主题或发件人包含关键词)"""
subject = (subject or "").lower()
from_addr = (from_addr or "").lower()
keywords = ["boss", "直聘", "zhipin", "博聘"]
for kw in keywords:
if kw in subject or kw in from_addr:
return True
return False
def _safe_filename(name: str) -> str:
"""去掉非法文件名字符"""
name = re.sub(r'[<>:"/\\|?*]', "_", name)
return name.strip() or "attachment"
def download_attachments_from_message(msg, date_str: str, global_index: int, saved: set) -> list[Path]:
"""从一封邮件中提取所有附件并保存,返回保存路径列表。"""
saved_paths = []
for part in msg.walk():
filename = part.get_filename()
if not filename:
continue
filename = _decode_mime(filename)
if not filename.strip():
continue
payload = part.get_payload(decode=True)
if payload is None:
continue
safe_base = _safe_filename(filename)
base, ext = os.path.splitext(safe_base)
path = DOWN_DIR / f"{date_str}_{global_index}_{safe_base}"
cnt = 0
while path in saved or path.exists():
cnt += 1
path = DOWN_DIR / f"{date_str}_{global_index}_{base}_{cnt}{ext}"
path.write_bytes(payload)
saved.add(path)
saved_paths.append(path)
return saved_paths
def main():
ap = argparse.ArgumentParser(description="下载邮箱中 Boss 直聘相关邮件的附件到下载目录")
ap.add_argument("--days", type=int, default=0, help="只处理最近 N 天的邮件0 表示全部")
args = ap.parse_args()
if not AUTH_CODE:
print("未配置 QQ 邮箱授权码,请在同目录 .qq_mail_env 中设置 QQ_MAIL_AUTH_CODE", file=sys.stderr)
return 1
DOWN_DIR.mkdir(parents=True, exist_ok=True)
print(f"下载目录: {DOWN_DIR}", file=sys.stderr)
server = imaplib.IMAP4_SSL(IMAP_HOST, IMAP_PORT)
server.login(EMAIL, AUTH_CODE)
# 收件箱 + 垃圾箱Boss 邮件有时会被归类到垃圾箱)
folders = [("INBOX", "收件箱"), ("Junk", "垃圾箱")]
total_saved = 0
saved_paths_global = set()
global_file_index = 0
# 可选按日期限制SINCE
since_criteria = ""
if args.days > 0:
since = (datetime.now() - timedelta(days=args.days)).strftime("%d-%b-%Y")
since_criteria = f'(SINCE {since})'
print(f"仅处理 {args.days} 天内邮件 (since {since})", file=sys.stderr)
for folder, label in folders:
mb = f'"{folder}"' if " " in folder else folder
try:
server.select(mb, readonly=True)
except Exception as e:
print(f"跳过 {label} ({folder}): {e}", file=sys.stderr)
continue
typ, data = server.search(None, since_criteria or "ALL")
if typ != "OK":
continue
ids = list(reversed(data[0].split()))
print(f"\n{label}: 共 {len(ids)} 封待检查...", file=sys.stderr)
for i, num in enumerate(ids):
typ, msg_data = server.fetch(num, "(RFC822)")
if typ != "OK":
continue
raw = msg_data[0][1]
msg = email.message_from_bytes(raw)
subject = _decode_mime(msg.get("Subject", ""))
from_addr = _decode_mime(msg.get("From", ""))
if not _is_boss_zhipin_email(subject, from_addr):
continue
date_str = msg.get("Date", "")[:10].replace(" ", "_") or "nodate"
date_str = re.sub(r"[^\d\-_]", "", date_str) or "nodate"
global_file_index += 1
paths = download_attachments_from_message(msg, date_str, global_file_index, saved_paths_global)
if paths:
total_saved += len(paths)
for p in paths:
print(p.name)
server.close()
server.logout()
print(f"\n合计下载 {total_saved} 个附件到: {DOWN_DIR}", file=sys.stderr)
return 0
if __name__ == "__main__":
sys.exit(main())

View File

@@ -0,0 +1,79 @@
# Soul 创业派对(永平版)- 项目管理概览
> 维护人卡若AI | 最后更新2026-03-19
> Gitea 仓库http://open.quwanzhi.com:3000/fnvtk/soul-yongping
> 本地路径:`/Users/karuo/Documents/开发/3、自营项目/一场soul的创业实验-永平`
---
## 项目架构
| 子项目 | 技术栈 | 目录 | 说明 |
|:---|:---|:---|:---|
| 小程序 | 微信原生WXML/WXSS/JS | `miniprogram/` | C 端阅读、会员、链接卡若 |
| 管理端 | React + TypeScript + Vite + Radix UI | `soul-admin/` | 后台管理、内容编辑、数据看板 |
| API 后端 | Go + Gin + GORM + MySQL | `soul-api/` | 统一接口服务 |
## API 路由分组(强制隔离)
- 小程序:`/api/miniprogram/*`
- 管理端:`/api/admin/*` + `/api/db/*`
- 禁止混用
## Gitea 同步机制
| 项 | 说明 |
|:---|:---|
| 公网 Gitea | `gitea``open.quwanzhi.com:3000/fnvtk/soul-yongping` |
| 同步脚本 | `.cursor/scripts/gitea-sync.sh` |
| 定时频率 | 每 10 分钟macOS launchd |
| 同步方式 | 双向:先 pull 远程更新 → 有本地变更则 commit+push |
| 分支 | `devlop` |
| launchd | `~/Library/LaunchAgents/com.soul.yongping.gitea-sync.plist` |
## 核心功能模块(截至 2026-03-19
### 已完成
| 模块 | 功能 | 涉及三端 |
|:---|:---|:---|
| 客资中心 | Dashboard 聚合 CKB 线索+提交记录,联表用户信息,展示联系方式 | 后端 + 管理端 |
| @置顶 | Person 三端置顶功能,管理端可配置,小程序首页优先展示 | 后端 + 管理端 + 小程序 |
| 存客宝场景 | 一键检查并自动启用场景获客计划 | 后端 + 管理端 |
| 线索去重 | 后端聚合 dupCount管理端展示重复标记和统计 | 后端 + 管理端 |
| 内容管理 | 章节 CRUD、富文本编辑、@人物、排序、批量操作 | 后端 + 管理端 |
| 会员体系 | VIP 开通/续费/过期、微信支付、权益管理 | 三端 |
| 用户系统 | 注册/登录、资料编辑、标签、推荐码 | 三端 |
| 阅读系统 | 章节阅读、进度追踪、分享、搜索 | 后端 + 小程序 |
| 数据看板 | 用户统计、订单统计、营收、商户余额 | 后端 + 管理端 |
### 进行中 / 待开发
| 模块 | 状态 | 说明 |
|:---|:---|:---|
| 用户 RFM 估值 | 待开发 | 基于旅程/习惯/标签计算 RFM 值 |
| 规则引擎 | 部分完成 | 注册规则、行为触发规则的完善和埋点 |
| 用户旅程 | 待开发 | 用户行为聚合展示 |
| 标签体系 | 部分完成 | 需与存客宝标签实时同步 |
| 获客计划匹配 | 部分完成 | 小程序文章@与存客宝计划绑定 |
| 支付问题修复 | 进行中 | 持续排查支付异常 |
## 关键文件索引
| 文件 | 说明 |
|:---|:---|
| `soul-api/internal/router/router.go` | 全部路由定义 |
| `soul-api/internal/model/` | 数据模型User, Person, Order 等) |
| `soul-api/internal/handler/` | 所有 API handler |
| `soul-admin/src/pages/dashboard/DashboardPage.tsx` | 管理端首页看板 |
| `soul-admin/src/pages/content/ContentPage.tsx` | 内容管理+@人物列表 |
| `miniprogram/pages/index/index.js` | 小程序首页 |
| `miniprogram/app.js` | 小程序全局配置 |
| `开发文档/1、需求/` | 需求文档目录 |
| `.cursor/skills/` | 各角色开发规范 Skill |
## 版本记录
| 日期 | 变更 |
|:---|:---|
| 2026-03-19 | 初始创建;四大用户功能完成(客资中心、@置顶、场景bug修复、去重增强Gitea 同步修复 |

View File

@@ -1,6 +1,6 @@
{
"access_token": "u-dK0qe.uCx3obAbLy2IlIXDlh1C31ghihhwGaJQg0230F",
"refresh_token": "ur-dX7EcveVR2N8ppLnCtagzqlh3I9xghWXi0GaJx00275Y",
"access_token": "u-e_yzrY5Mh5eF_.Y8PKbaMtlh14HxghqpWMGaIQ40235J",
"refresh_token": "ur-ew8WjjPF9e1HoSim4iMK8Qlh1A11ghOpq0GaZwg0260F",
"name": "飞书用户",
"auth_time": "2026-03-14T12:12:52.532017"
"auth_time": "2026-03-20T11:02:06.903826"
}

View File

@@ -63,11 +63,13 @@ ROWS = {
'127': [ '占卜玄学 AI职业定位TOKEN', 127, 0, 174, 10, 60, 18, 69, 14, 32 ],
# 128场 2026-03-19关闭页 187min/236成员/37最高/19新增/2礼物/29灵魂力小助手 185min建房/233进房/13人均/102互动/19关注话题知识
'128': [ '分享最赚钱一个月-知识节奏', 187, 0, 233, 13, 102, 2, 29, 19, 37 ],
# 129场 2026-03-20关闭页 200min/252成员/31最高/21新增/4礼物/561灵魂力/灵果+5257小助手 200min建房/250进房/14人均/187互动/21关注话题职场
'129': [ '分享最赚钱一月职场', 200, 0, 250, 14, 187, 4, 561, 21, 31 ],
}
# 场次→按日期列填写时的日期(表头为当月日期 1~31
SESSION_DATE_COLUMN = {'105': '20', '106': '21', '107': '23', '113': '2', '114': '3', '115': '4', '116': '5', '117': '6', '118': '7', '119': '8', '124': '14', '126': '17', '127': '18', '128': '19'}
SESSION_DATE_COLUMN = {'105': '20', '106': '21', '107': '23', '113': '2', '114': '3', '115': '4', '116': '5', '117': '6', '118': '7', '119': '8', '124': '14', '126': '17', '127': '18', '128': '19', '129': '20'}
# 场次→月份(用于选择 2月/3月 等工作表标签,避免写入错月)
SESSION_MONTH = {'105': 2, '106': 2, '107': 2, '113': 3, '114': 3, '115': 3, '116': 3, '117': 3, '118': 3, '119': 3, '124': 3, '126': 3, '127': 3, '128': 3}
SESSION_MONTH = {'105': 2, '106': 2, '107': 2, '113': 3, '114': 3, '115': 3, '116': 3, '117': 3, '118': 3, '119': 3, '124': 3, '126': 3, '127': 3, '128': 3, '129': 3}
# 派对录屏(飞书妙记)链接:场次 → 完整 URL填表时写入「派对录屏」行对应列
# 从飞书妙记复制链接后填入,新场次需补全
@@ -82,6 +84,7 @@ PARTY_VIDEO_LINKS = {
'124': 'https://cunkebao.feishu.cn/minutes/obcne7q5dto13494k9a56881',
'126': 'https://cunkebao.feishu.cn/minutes/obcnha23t28fxfq8g8h5392d',
'127': 'https://cunkebao.feishu.cn/minutes/obcnhybw322112tad6916v8r',
'129': 'https://cunkebao.feishu.cn/minutes/obcnjb994323l12lhl448177',
}
# 团队会议(飞书妙记)链接:场次 → 完整 URL填表时写入「团队会议」行对应列row 31
@@ -118,6 +121,7 @@ MINIPROGRAM_EXTRA_3 = {
'17': {'访问次数': 0, '访客': 0, '交易金额': 0}, # 3月17日 126场
'18': {'访问次数': 0, '访客': 0, '交易金额': 0}, # 3月18日 127场
'19': {'访问次数': 0, '访客': 0, '交易金额': 0}, # 3月19日 128场
'20': {'访问次数': 0, '访客': 0, '交易金额': 0}, # 3月20日 129场
}
@@ -449,9 +453,9 @@ def main():
LABELS_GROUP = ['主题', '时长(分钟)', 'Soul推流人数', '进房人数', '人均时长(分钟)', '互动数量', '礼物', '灵魂力', '增加关注', '最高在线']
def _maybe_send_group(sess, raw_vals):
if sess not in ('105', '106', '107', '113', '114', '115', '116', '117', '118', '119', '124', '126', '127', '128'):
if sess not in ('105', '106', '107', '113', '114', '115', '116', '117', '118', '119', '124', '126', '127', '128', '129'):
return
date_label = {'105': '2月20日', '106': '2月21日', '107': '2月23日', '113': '3月2日', '114': '3月3日', '115': '3月4日', '116': '3月5日', '117': '3月6日', '118': '3月7日', '119': '3月8日', '124': '3月14日', '126': '3月17日', '127': '3月18日', '128': '3月19日'}.get(sess, sess + '')
date_label = {'105': '2月20日', '106': '2月21日', '107': '2月23日', '113': '3月2日', '114': '3月3日', '115': '3月4日', '116': '3月5日', '117': '3月6日', '118': '3月7日', '119': '3月8日', '124': '3月14日', '126': '3月17日', '127': '3月18日', '128': '3月19日', '129': '3月20日'}.get(sess, sess + '')
report_link = OPERATION_REPORT_LINK if sheet_id == SHEET_ID else f'https://cunkebao.feishu.cn/wiki/wikcnIgAGSNHo0t36idHJ668Gfd?sheet={sheet_id}'
lines = [
'【Soul 派对运营报表】',
@@ -462,7 +466,7 @@ def main():
for i, label in enumerate(LABELS_GROUP):
val = raw_vals[i] if i < len(raw_vals) else ''
lines.append(f'{label}{val}')
src_date = {'105': '20260220', '106': '20260221', '107': '20260223', '113': '20260302', '114': '20260303', '115': '20260304', '116': '20260305', '117': '20260306', '118': '20260307', '119': '20260308', '124': '20260314', '126': '20260317', '127': '20260318', '128': '20260319'}.get(sess, '20260220')
src_date = {'105': '20260220', '106': '20260221', '107': '20260223', '113': '20260302', '114': '20260303', '115': '20260304', '116': '20260305', '117': '20260306', '118': '20260307', '119': '20260308', '124': '20260314', '126': '20260317', '127': '20260318', '128': '20260319', '129': '20260320'}.get(sess, '20260220')
lines.append(f'数据来源soul 派对 {sess}{src_date}.txt')
msg = '\n'.join(lines)
ok, _ = send_feishu_group_message(FEISHU_GROUP_WEBHOOK, msg)

View File

@@ -19,9 +19,9 @@ updated: "2026-02-16"
## 🎯 核心功能
### 1. 自动读取记忆
- 每次对话开始时,自动读取 `/Users/karuo/Documents/个人/记忆.md`
- 读取分类记忆目录下的所有文档
- 将记忆内容作为上下文指导AI行为
- 每次对话开始时,自动读取 `/Users/karuo/Documents/个人/1、卡若本人/记忆.md`(唯一记忆源)
- 可选从 **MongoDB** 调取:库 `karuo_site`,集合 `记忆条目`(中文字段、分类清晰),便于对话中按分类/标签/关键词/最近 N 条快速检索
- 将记忆内容作为上下文,指导 AI 行为
### 2. 自动识别优质内容
识别以下类型的优质内容:
@@ -64,17 +64,39 @@ updated: "2026-02-16"
### 手动触发
用户说:`记住这个` `存入记忆` `更新记忆`
### 从 MongoDB 调取记忆(对话中快速检索)
记忆已同步到唯一 MongoDB`karuo_site.记忆条目`),可用以下命令在对话中按需调取:
| 需求 | 命令 |
|:---|:---|
| 统计 | `python3 记忆系统/query_memory.py --stats` |
| 最近 N 条 | `python3 记忆系统/query_memory.py --最近 20` |
| 按分类 | `python3 记忆系统/query_memory.py --分类 固定偏好` |
| 按标签 | `python3 记忆系统/query_memory.py --标签 规则` |
| 按日期 | `python3 记忆系统/query_memory.py --日期 2026-03-15` |
| 关键词 | `python3 记忆系统/query_memory.py --关键词 飞书` |
脚本路径:`02_卡人/水溪_整理归档/记忆系统/query_memory.py`。同步 记忆.md → MongoDB`python3 sync_memory_to_mongo.py`(全量)、`--dry` 仅解析不写入。
---
## 🔧 技术实现
### 核心脚本
`scripts/memory_manager.py` - 记忆管理核心逻辑
### 核心脚本与 MongoDB
**主要功能**
| 脚本/模块 | 用途 |
|:---|:---|
| `scripts/memory_manager.py` | 记忆管理:读 记忆.md、分类、写入 记忆.md |
| 记忆系统/`memory_mongo.py` | MongoDB 读写:库 `karuo_site`,集合 `记忆条目`(中文字段) |
| 记忆系统/`sync_memory_to_mongo.py` | 将 记忆.md 解析后同步到 MongoDB去重 |
| 记忆系统/`query_memory.py` | 按分类/标签/日期/关键词/最近 N 条查询,输出中文易读 |
**MongoDB 记忆条目**:与 记忆.md 对应;分类为「固定偏好」「近期目标」「每日沉淀」,标签为规则、原则、项目、技术、人脉、工具、读书笔记等。对话中需要快速调取时,可执行 `python3 query_memory.py --最近 20``--关键词 飞书``--分类 固定偏好` 等。
**主要功能**memory_manager.py
1. `read_memory()` - 读取所有记忆文档
2. `classify_content()` - 使用本地模型分类内容
3. `save_memory()` - 保存到对应位置
3. `save_memory()` - 保存到对应位置(记忆.md同步到 MongoDB 需另跑 `sync_memory_to_mongo.py` 或由调用方双写)
4. `format_entry()` - 格式化记忆条目
### 调用示例

View File

@@ -0,0 +1,259 @@
#!/usr/bin/env python3
"""
卡若AI 记忆 · MongoDB 读写模块
- 库karuo_site唯一 MongoDB 27017
- 集合:记忆条目(中文字段,便于 AI 理解与调取)
- 支持:按分类、标签、日期、关键词、最近 N 条查询;写入时去重(内容哈希)
"""
import hashlib
import re
from datetime import datetime, timezone
from pathlib import Path
from typing import Any, Dict, List, Optional
try:
from pymongo import MongoClient, ASCENDING, DESCENDING, TEXT
except ImportError:
MongoClient = None # type: ignore
# 配置(与聊天记录管理一致,遵守唯一 MongoDB 约定)
MONGO_URI = "mongodb://admin:admin123@localhost:27017/?authSource=admin"
DB_NAME = "karuo_site"
COLLECTION = "记忆条目"
# 记忆.md 路径(与 BOOTSTRAP 一致)
MEMORY_MD = Path("/Users/karuo/Documents/个人/1、卡若本人/记忆.md")
# 分类枚举(中文)
分类_固定偏好 = "固定偏好"
分类_近期目标 = "近期目标"
分类_每日沉淀 = "每日沉淀"
# 标签从原文 [xxx] 解析,常见值
常见标签 = frozenset({
"规则", "原则", "项目", "技术", "商业", "学习", "偏好", "人脉", "工具",
"读书笔记", "经验", "能力沉淀", "人设", "其他"
})
def _get_client():
if MongoClient is None:
raise RuntimeError("需要安装 pymongo: pip install pymongo")
return MongoClient(MONGO_URI, serverSelectionTimeoutMS=5000)
def get_db():
"""返回 (client, db)。调用方用完可关闭 client。"""
client = _get_client()
client.admin.command("ping")
return client, client[DB_NAME]
def 内容哈希(日期: str, 时间: str, 内容: str) -> str:
"""生成条目唯一标识,用于去重。"""
raw = f"{日期}|{时间}|{内容.strip()}"
return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
def ensure_indexes(db):
"""确保 记忆条目 集合索引存在(含中文全文索引)。"""
col = db[COLLECTION]
col.create_index([("分类", ASCENDING), ("日期", DESCENDING)])
col.create_index([("标签", ASCENDING), ("日期", DESCENDING)])
col.create_index([("日期", DESCENDING)])
col.create_index([("创建时间", DESCENDING)])
col.create_index([("内容哈希", ASCENDING)], unique=True)
try:
col.create_index([("内容", TEXT)], default_language="none")
except Exception:
pass # 已有或不支持时忽略
def 解析一行(: str, 当前分类: str, 当前日期: Optional[str]) -> Optional[Dict[str, Any]]:
"""
解析 记忆.md 中一行条目:
- [HH:MM] [标签] 内容 或 - [HH:MM] 内容
返回 None 表示不是条目行;否则返回 分类、标签、日期、时间、内容。
"""
= .strip()
if not .startswith("- [") or "]" not in :
return None
m = re.match(r"^-\s*\[(\d{1,2}:\d{2})\]\s*(?:\[([^\]]+)\]\s*)?(.*)$", )
if not m:
return None
时间, 标签, 内容 = m.group(1), m.group(2) or "", m.group(3).strip()
if not 内容:
return None
标签 = (标签.strip() if 标签 else "其他") or "其他"
if 当前日期 is None and 当前分类 == 分类_每日沉淀:
日期 = datetime.now().strftime("%Y-%m-%d")
elif 当前日期 in (None, "") and 当前分类 in (分类_固定偏好, 分类_近期目标):
日期 = "长期"
else:
日期 = 当前日期 or datetime.now().strftime("%Y-%m-%d")
return {
"分类": 当前分类,
"标签": 标签 if 标签 else "其他",
"日期": 日期,
"时间": 时间,
"内容": 内容,
}
def 解析记忆md全文(文本: str) -> List[Dict[str, Any]]:
"""
解析 记忆.md 全文,得到结构化条目列表。
识别:## 固定偏好 / ## 近期目标 / ## 每日沉淀;### YYYY-MM-DD 为日期。
"""
条目列表 = []
当前分类 = ""
当前日期 = None
for line in 文本.splitlines():
line = line.strip()
if line.startswith("## "):
if "固定偏好" in line:
当前分类 = 分类_固定偏好
当前日期 = "" # 无日期块,解析时用「长期」
elif "近期目标" in line:
当前分类 = 分类_近期目标
当前日期 = ""
elif "每日沉淀" in line:
当前分类 = 分类_每日沉淀
当前日期 = None # 等待 ### YYYY-MM-DD
else:
当前分类 = ""
当前日期 = None
continue
if line.startswith("### ") and re.match(r"### \d{4}-\d{2}-\d{2}", line):
m = re.match(r"### (\d{4}-\d{2}-\d{2})", line)
if m and 当前分类 == 分类_每日沉淀:
当前日期 = m.group(1)
continue
if 当前分类:
one = 解析一行(line, 当前分类, 当前日期)
if one:
条目列表.append(one)
return 条目列表
def 写入一条(
db,
分类: str,
内容: str,
标签: str = "其他",
日期: Optional[str] = None,
时间: Optional[str] = None,
来源: str = "记忆.md",
) -> bool:
"""
写入一条记忆到 MongoDB。若 内容哈希 已存在则跳过(去重)。
"""
now = datetime.now(timezone.utc)
日期 = 日期 or now.strftime("%Y-%m-%d")
时间 = 时间 or now.strftime("%H:%M")
摘要 = 内容[:120] + "" if len(内容) > 120 else 内容
内容哈希_val = 内容哈希(日期, 时间, 内容)
doc = {
"分类": 分类,
"标签": 标签,
"日期": 日期,
"时间": 时间,
"内容": 内容,
"摘要": 摘要,
"来源": 来源,
"创建时间": now,
"内容哈希": 内容哈希_val,
}
col = db[COLLECTION]
try:
col.insert_one(doc)
return True
except Exception as e:
if "duplicate" in str(e).lower() or "E11000" in str(e):
return False # 已存在,算成功
raise
def 按分类查(db, 分类: str, limit: int = 50) -> List[Dict]:
"""按分类查询,按日期倒序。"""
return list(
db[COLLECTION]
.find({"分类": 分类})
.sort("日期", DESCENDING)
.limit(limit)
)
def 按标签查(db, 标签: str, limit: int = 50) -> List[Dict]:
"""按标签查询,按日期倒序。"""
return list(
db[COLLECTION]
.find({"标签": 标签})
.sort("日期", DESCENDING)
.limit(limit)
)
def 按日期查(db, 日期: str) -> List[Dict]:
"""按日期查询。"""
return list(db[COLLECTION].find({"日期": 日期}).sort("时间", ASCENDING))
def 按关键词查(db, 关键词: str, limit: int = 30) -> List[Dict]:
"""全文检索(内容字段)。中文或短词用正则,否则尝试 text 索引。"""
col = db[COLLECTION]
# 中文或短关键词用正则,便于「飞书」「规则」等直接命中
is_cjk = any("\u4e00" <= c <= "\u9fff" for c in 关键词)
if is_cjk or len(关键词) <= 4:
return list(
col.find({"内容": {"$regex": re.escape(关键词), "$options": "i"}})
.sort("日期", DESCENDING)
.limit(limit)
)
try:
cursor = col.find(
{"$text": {"$search": 关键词}},
{"score": {"$meta": "textScore"}},
).sort([("score", {"$meta": "textScore"})]).limit(limit)
return list(cursor)
except Exception:
return list(
col.find({"内容": {"$regex": re.escape(关键词), "$options": "i"}})
.sort("日期", DESCENDING)
.limit(limit)
)
def 最近N条(db, n: int = 30, 分类: Optional[str] = None, 标签: Optional[str] = None) -> List[Dict]:
"""最近 N 条,可选按分类或标签过滤;按创建时间倒序。"""
q = {}
if 分类:
q["分类"] = 分类
if 标签:
q["标签"] = 标签
return list(db[COLLECTION].find(q).sort("创建时间", DESCENDING).limit(n))
def 统计(db) -> Dict[str, int]:
"""按分类统计条数。"""
pipeline = [
{"$group": {"_id": "$分类", "数量": {"$sum": 1}}},
{"$sort": {"数量": -1}},
]
by_class = {doc["_id"]: doc["数量"] for doc in db[COLLECTION].aggregate(pipeline)}
by_class["总计"] = sum(by_class.values())
return by_class
if __name__ == "__main__":
import sys
client, db = get_db()
ensure_indexes(db)
if len(sys.argv) > 1 and sys.argv[1] == "stats":
for k, v in 统计(db).items():
print(f" {k}: {v}")
else:
print("memory_mongo: 记忆条目读写。用法: python memory_mongo.py stats")
client.close()

View File

@@ -0,0 +1,46 @@
# 卡若AI 记忆 · MongoDB 存储约定
> 库:`karuo_site`(唯一 MongoDB 实例 27017
> 集合:`记忆条目`
> 用途:长期记忆结构化存储,便于 AI 对话中按分类/日期/关键词快速调取;与 `1、卡若本人/记忆.md` 双写/同步。
---
## 集合:记忆条目
| 字段(中文) | 类型 | 说明 | 索引 |
|:---|:---|:---|:---|
| **分类** | string | 固定偏好 / 近期目标 / 每日沉淀 | 有 |
| **标签** | string | 从条目内 [标签] 解析:规则、原则、项目、技术、人脉、工具、读书笔记、经验、能力沉淀、人设 等 | 有 |
| **日期** | string | YYYY-MM-DD | 有 |
| **时间** | string | HH:MM | 有 |
| **内容** | string | 原文一条,中文 | 全文检索 |
| **摘要** | string | 可选,供快速调取用 | - |
| **来源** | string | 记忆.md / 对话写入 | 有 |
| **创建时间** | date | ISODate写入库时间 | 有 |
| **内容哈希** | string | 对「日期+时间+内容」的短哈希,用于去重 | 唯一 |
---
## 分类与标签(中文,便于 AI 理解)
- **分类**:固定偏好、近期目标、每日沉淀
- **标签**(来自原文 `[xxx]`):规则、原则、项目、技术、商业、学习、偏好、人脉、工具、读书笔记、经验、能力沉淀、人设、其他
---
## 索引
- `分类` + `日期`:按分类查某段时间
- `标签` + `日期`:按标签查
- `日期`:按日期倒序
- `创建时间`:按写入时间
- `内容`全文索引text支持关键词检索
---
## 与 记忆.md 的关系
- **同步方向**:记忆.md 为权威来源;`sync_memory_to_mongo.py` 将 记忆.md 解析后写入/更新 MongoDB。
- **写入**:新记忆可双写(同时追加 记忆.md + 插入 记忆条目);或仅写 记忆.md再由同步脚本入库。
- **读取**:对话中可从 MongoDB 按分类/标签/关键词/最近 N 条查询,返回中文结构化结果,供 AI 直接使用。

View File

@@ -0,0 +1,115 @@
#!/usr/bin/env python3
"""
卡若AI 记忆 · 查询工具MongoDB
便于 AI 或人在对话中按分类/标签/关键词/最近 N 条快速调取,输出中文易读。
用法:
python3 query_memory.py --stats
python3 query_memory.py --分类 固定偏好
python3 query_memory.py --标签 规则
python3 query_memory.py --日期 2026-03-15
python3 query_memory.py --关键词 飞书
python3 query_memory.py --最近 20
python3 query_memory.py --最近 10 --分类 每日沉淀
"""
import argparse
import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent))
from memory_mongo import (
get_db,
ensure_indexes,
按分类查,
按标签查,
按日期查,
按关键词查,
最近N条,
统计,
)
def _fmt(doc):
"""单条格式化为一行中文,便于 AI 理解。"""
日期 = doc.get("日期", "")
时间 = doc.get("时间", "")
标签 = doc.get("标签", "")
内容 = (doc.get("内容") or doc.get("摘要", ""))[:200]
if 标签 and 标签 != "其他":
return f"- [{日期} {时间}] [{标签}] {内容}"
return f"- [{日期} {时间}] {内容}"
def _fallback_记忆md(limit_lines=80):
"""MongoDB 不可用时从 记忆.md 读取并输出最近若干行。"""
from memory_mongo import MEMORY_MD
print("【MongoDB 不可用,以下来自 记忆.md】\n", file=sys.stderr)
if not MEMORY_MD.exists():
print("记忆.md 不存在")
return
with open(MEMORY_MD, "r", encoding="utf-8") as f:
lines = f.readlines()
tail = lines[-limit_lines:] if len(lines) > limit_lines else lines
print("".join(tail).rstrip())
def main():
ap = argparse.ArgumentParser(description="记忆条目查询MongoDB")
ap.add_argument("--stats", action="store_true", help="按分类统计条数")
ap.add_argument("--分类", type=str, metavar="名称", help="按分类查:固定偏好 / 近期目标 / 每日沉淀")
ap.add_argument("--标签", type=str, metavar="名称", help="按标签查:规则、原则、项目、技术等")
ap.add_argument("--日期", type=str, metavar="YYYY-MM-DD", help="按日期查")
ap.add_argument("--关键词", type=str, metavar="", help="全文检索内容")
ap.add_argument("--最近", type=int, metavar="N", help="最近 N 条;可配合 --分类/--标签")
ap.add_argument("-n", "--limit", type=int, default=50, help="条数上限,默认 50")
args = ap.parse_args()
try:
client, db = get_db()
ensure_indexes(db)
except Exception as e:
print(f"MongoDB 连接失败: {e},降级为 记忆.md", file=sys.stderr)
_fallback_记忆md(limit_lines=100)
return
if args.stats:
for k, v in 统计(db).items():
print(f" {k}: {v}")
client.close()
return
if args.分类:
rows = 按分类查(db, args.分类, limit=args.limit)
print(f"【分类】{args.分类}{len(rows)}\n")
for doc in rows:
print(_fmt(doc))
elif args.标签:
rows = 按标签查(db, args.标签, limit=args.limit)
print(f"【标签】{args.标签}{len(rows)}\n")
for doc in rows:
print(_fmt(doc))
elif args.日期:
rows = 按日期查(db, args.日期)
print(f"【日期】{args.日期}{len(rows)}\n")
for doc in rows:
print(_fmt(doc))
elif args.关键词:
rows = 按关键词查(db, args.关键词, limit=args.limit)
print(f"【关键词】{args.关键词}{len(rows)}\n")
for doc in rows:
print(_fmt(doc))
elif args.最近:
rows = 最近N条(db, n=args.最近, 分类=args.分类 or None, 标签=args.标签 or None)
print(f"【最近 {args.最近} 条】\n")
for doc in rows:
print(_fmt(doc))
else:
ap.print_help()
print("\n示例: python3 query_memory.py --最近 20")
client.close()
if __name__ == "__main__":
main()

View File

@@ -0,0 +1,85 @@
#!/usr/bin/env python3
"""
卡若AI 记忆 · 从 记忆.md 同步到 MongoDB
- 读取 1、卡若本人/记忆.md
- 解析为结构化条目(分类、标签、日期、时间、内容)
- 写入 karuo_site.记忆条目,以 内容哈希 去重(已存在则跳过)
用法:
python3 sync_memory_to_mongo.py # 全量同步
python3 sync_memory_to_mongo.py --dry # 仅解析并打印,不写入
"""
import argparse
import sys
from pathlib import Path
# 同目录
sys.path.insert(0, str(Path(__file__).resolve().parent))
from memory_mongo import (
MEMORY_MD,
get_db,
ensure_indexes,
解析记忆md全文,
内容哈希,
COLLECTION,
)
def main():
ap = argparse.ArgumentParser(description="记忆.md → MongoDB 同步")
ap.add_argument("--dry", action="store_true", help="仅解析不写入")
args = ap.parse_args()
if not MEMORY_MD.exists():
print(f"未找到记忆文件: {MEMORY_MD}")
sys.exit(1)
文本 = MEMORY_MD.read_text(encoding="utf-8")
条目列表 = 解析记忆md全文(文本)
print(f"解析到 {len(条目列表)} 条记忆条目。")
if args.dry:
for i, e in enumerate(条目列表[:15]):
print(f" [{i+1}] {e.get('日期')} {e.get('时间')} [{e.get('标签')}] {e.get('内容', '')[:60]}")
if len(条目列表) > 15:
print(f" ... 共 {len(条目列表)}")
return
client, db = get_db()
ensure_indexes(db)
col = db[COLLECTION]
新增 = 0
跳过 = 0
for e in 条目列表:
日期 = e.get("日期", "")
时间 = e.get("时间", "")
内容 = e.get("内容", "")
if not 内容:
continue
h = 内容哈希(日期, 时间, 内容)
if col.find_one({"内容哈希": h}):
跳过 += 1
continue
from datetime import datetime, timezone
doc = {
"分类": e.get("分类", "每日沉淀"),
"标签": e.get("标签", "其他"),
"日期": 日期,
"时间": 时间,
"内容": 内容,
"摘要": 内容[:120] + "" if len(内容) > 120 else 内容,
"来源": "记忆.md",
"创建时间": datetime.now(timezone.utc),
"内容哈希": h,
}
col.insert_one(doc)
新增 += 1
client.close()
print(f"同步完成: 新增 {新增} 条,跳过已存在 {跳过} 条。")
if __name__ == "__main__":
main()

View File

@@ -0,0 +1,285 @@
# 记忆系统连接机制说明
> **核心机制**:本地记忆.md ↔ MongoDB 记忆条目 双向同步与查询
## 一、系统架构
### 1.1 数据源层次
```
┌─────────────────────────────────────┐
│ 权威来源:记忆.md │
│ /Users/karuo/Documents/个人/ │
│ 1、卡若本人/记忆.md │
│ (单文件,无子目录) │
└──────────────┬──────────────────────┘
│ sync_memory_to_mongo.py
│ (解析 → 结构化 → 写入)
┌─────────────────────────────────────┐
│ MongoDBkaruo_site.记忆条目 │
│ (结构化存储,便于查询) │
│ - 分类:固定偏好/近期目标/每日沉淀 │
│ - 标签:规则/原则/项目/技术等 │
│ - 索引:分类+日期/标签+日期/全文 │
└──────────────┬──────────────────────┘
│ query_memory.py
│ (按分类/标签/关键词/最近N条查询
┌─────────────────────────────────────┐
│ AI对话调用 │
快速检索记忆指导AI行为
└─────────────────────────────────────┘
```
### 1.2 数据流向
**写入流程**
1. 用户/对话 → 写入 `记忆.md`(权威来源)
2. 执行 `sync_memory_to_mongo.py` → 解析记忆.md → 写入MongoDB
3. MongoDB自动去重基于内容哈希
**读取流程**
1. AI对话需要记忆 → 调用 `query_memory.py`
2. 从MongoDB查询按分类/标签/关键词/最近N条
3. MongoDB不可用时 → 自动降级读取 `记忆.md`
## 二、连接机制详解
### 2.1 本地记忆文件
**路径**`/Users/karuo/Documents/个人/1、卡若本人/记忆.md`
**格式**
```markdown
## 固定偏好
- [00:00] 默认简体中文、直白大白话、给行动清单。
- [00:00] 每轮回复末尾带复盘;对话结束给完整复盘。
## 近期目标
- [00:00] (待补充)
- [16:10] [原则] 每日在复盘上做一轮功课...
## 每日沉淀
### 2026-03-12
- [17:15] [规则] 飞书文档统一执行 W16...
- [17:15] [规则] 飞书表格策略...
```
**特点**
- 单文件,无子目录
- 按日期分组(每日沉淀)
- 支持标签:`[规则]``[原则]``[项目]``[技术]`
- 时间戳格式:`[HH:MM]`
### 2.2 MongoDB存储结构
**数据库**`karuo_site`唯一MongoDB实例端口27017
**集合**`记忆条目`
**字段结构**
```javascript
{
"分类": "固定偏好" | "近期目标" | "每日沉淀",
"标签": "规则" | "原则" | "项目" | "技术" | "其他",
"日期": "YYYY-MM-DD" | "长期",
"时间": "HH:MM",
"内容": "记忆条目原文",
"摘要": "内容前120字符",
"来源": "记忆.md" | "对话写入",
"创建时间": ISODate,
"内容哈希": "sha256前16位用于去重"
}
```
**索引**
- `分类 + 日期`:按分类查某段时间
- `标签 + 日期`:按标签查
- `日期`:按日期倒序
- `创建时间`:按写入时间
- `内容`全文索引text
- `内容哈希`:唯一索引(去重)
### 2.3 同步机制
**脚本**`sync_memory_to_mongo.py`
**功能**
1. 读取 `记忆.md` 全文
2. 解析为结构化条目(分类、标签、日期、时间、内容)
3. 计算内容哈希(日期+时间+内容的SHA256前16位
4. 写入MongoDB已存在则跳过实现去重
**执行方式**
```bash
# 全量同步
python3 sync_memory_to_mongo.py
# 仅解析不写入(检查)
python3 sync_memory_to_mongo.py --dry
```
**去重机制**
- 基于 `内容哈希`(日期+时间+内容的SHA256
- 已存在的条目自动跳过
- 确保不重复写入
### 2.4 查询机制
**脚本**`query_memory.py`
**查询方式**
```bash
# 统计
python3 query_memory.py --stats
# 最近N条
python3 query_memory.py --最近 20
# 按分类
python3 query_memory.py --分类 固定偏好
# 按标签
python3 query_memory.py --标签 规则
# 按日期
python3 query_memory.py --日期 2026-03-15
# 关键词搜索
python3 query_memory.py --关键词 飞书
# 组合查询
python3 query_memory.py --最近 10 --分类 每日沉淀
```
**降级机制**
- MongoDB不可用时自动读取 `记忆.md` 最近100行
- 确保查询始终可用
## 三、当前连接状态
### 3.1 数据统计
**MongoDB记忆条目**
- 每日沉淀39条
- 固定偏好2条
- 近期目标2条
- **总计43条**
**本地记忆.md**
- 解析条目43条
- 同步状态:✅ 已完全同步新增0条跳过43条
### 3.2 连接验证
执行同步检查:
```bash
python3 sync_memory_to_mongo.py
# 输出:同步完成: 新增 0 条,跳过已存在 43 条。
```
**结论**:本地记忆.md 与 MongoDB 记忆条目已完全同步 ✅
## 四、使用场景
### 4.1 对话开始时
**自动读取记忆**
-`记忆.md` 读取(权威来源)
- 或从MongoDB查询最近N条快速检索
- 作为上下文指导AI行为
### 4.2 对话结束时
**写入新记忆**
1. 识别优质内容(项目/技术/商业/学习/偏好/人脉/原则)
2. 写入 `记忆.md`(追加到对应日期下)
3. 执行 `sync_memory_to_mongo.py` 同步到MongoDB
### 4.3 对话中查询
**快速检索记忆**
```bash
# 查询相关记忆
python3 query_memory.py --关键词 飞书
python3 query_memory.py --标签 规则
python3 query_memory.py --最近 20
```
## 五、对话写入记忆机制
### 5.1 当前机制
**写入流程**
1. 对话中识别优质内容
2. 写入 `记忆.md`(手动或自动)
3. 执行 `sync_memory_to_mongo.py` 同步到MongoDB
### 5.2 优化建议
**自动同步机制**
- 对话结束时,自动检测是否有新记忆写入
- 如有新记忆,自动执行 `sync_memory_to_mongo.py`
- 或实现双写机制:同时写入 `记忆.md` 和 MongoDB
**实现方式**
```python
# 在对话结束时
if 有新记忆写入:
# 方式1写入记忆.md后自动同步
write_to_memory_md(content)
sync_to_mongo() # 自动调用
# 方式2双写同时写入
write_to_memory_md(content)
write_to_mongo(content) # 直接写入MongoDB
```
## 六、相关文件
| 文件 | 用途 |
|:---|:---|
| `记忆.md` | 权威记忆源(单文件) |
| `memory_mongo.py` | MongoDB读写模块 |
| `sync_memory_to_mongo.py` | 记忆.md → MongoDB同步 |
| `query_memory.py` | MongoDB查询工具 |
| `memory_mongo_schema.md` | MongoDB存储结构说明 |
## 七、维护建议
### 7.1 定期同步
**建议**:每次对话结束后,如有新记忆写入,执行一次同步:
```bash
python3 sync_memory_to_mongo.py
```
### 7.2 数据一致性检查
**定期检查**
```bash
# 检查统计
python3 query_memory.py --stats
# 检查最近条目
python3 query_memory.py --最近 10
# 验证同步
python3 sync_memory_to_mongo.py --dry
```
### 7.3 优化方向
1. **自动同步**对话写入记忆后自动同步到MongoDB
2. **双写机制**:同时写入记忆.md和MongoDB减少同步步骤
3. **增量同步**:只同步新增条目,提升性能
4. **冲突检测**:检测记忆.md和MongoDB的差异提示处理
## 八、版本历史
| 日期 | 变更 |
|:---|:---|
| 2026-03-20 | 创建连接机制说明文档,梳理记忆.md与MongoDB的连接关系 |

View File

@@ -228,3 +228,15 @@
{"platform": "抖音", "video_path": "/Users/karuo/Movies/soul视频/soul_派对_121场_20260311_output/成片/Cursor的权限问题安全隐患必须提前讲清楚.mp4", "title": "Cursor的权限问题安全隐患必须提前讲清楚 #Soul派对 #创业日记 #小程序 卡若创业派对", "success": false, "status": "error", "message": "未找到上传控件", "elapsed_sec": 18.89427924156189, "timestamp": "2026-03-16 16:44:36"}
{"platform": "抖音", "video_path": "/Users/karuo/Movies/soul视频/soul_派对_121场_20260311_output/成片/NFC碰一碰引流线下餐饮店用这招就够了.mp4", "title": "NFC碰一碰引流线下餐饮店用这招就够了 #Soul派对 #创业日记 #小程序 卡若创业派对", "success": false, "status": "error", "message": "未找到上传控件", "elapsed_sec": 8.366912841796875, "timestamp": "2026-03-16 16:44:52"}
{"platform": "抖音", "video_path": "/Users/karuo/Movies/soul视频/soul_派对_121场_20260311_output/成片/Skill和Cursor的区别一个走工作流一个走对话.mp4", "title": "Skill和Cursor的区别一个走工作流一个走对话 #Soul派对 #创业日记 #小程序 卡若创业派对", "success": false, "status": "error", "message": "未找到上传控件", "elapsed_sec": 8.569876909255981, "timestamp": "2026-03-16 16:45:11"}
{"platform": "抖音", "video_path": "/Users/karuo/Movies/soul视频/soul 派对 120场 20260320_output/成片/AI最大的缺点是上下文太短这样来解决.mp4", "title": "AI的短板是记忆太短上下文一长就废了这个方法能解决", "success": false, "status": "error", "message": "Cookie 已过期", "elapsed_sec": 0.8021829128265381, "timestamp": "2026-03-20 05:39:38"}
{"platform": "抖音", "video_path": "/Users/karuo/Movies/soul视频/soul 派对 120场 20260320_output/成片/AI每天剪1000个视频 M4电脑24T素材库全网分发.mp4", "title": "M4芯片+24T素材库AI每天剪1000条视频自动全网分发", "success": false, "status": "error", "message": "Cookie 已过期", "elapsed_sec": 0.19123601913452148, "timestamp": "2026-03-20 05:39:41"}
{"platform": "抖音", "video_path": "/Users/karuo/Movies/soul视频/soul 派对 120场 20260320_output/成片/Soul派对变现全链路 发视频就有钱,后端全解决.mp4", "title": "Soul派对怎么商业转化发视频就有收益后端体系全部搞定", "success": false, "status": "error", "message": "Cookie 已过期", "elapsed_sec": 0.21785306930541992, "timestamp": "2026-03-20 05:39:44"}
{"platform": "抖音", "video_path": "/Users/karuo/Movies/soul视频/soul 派对 120场 20260320_output/成片/从0到切片发布 AI自动完成每天副业30条视频.mp4", "title": "从零到切片发布AI全自动完成每天副业产出30条视频", "success": false, "status": "error", "message": "Cookie 已过期", "elapsed_sec": 0.17282390594482422, "timestamp": "2026-03-20 05:39:47"}
{"platform": "抖音", "video_path": "/Users/karuo/Movies/soul视频/soul 派对 120场 20260320_output/成片/做副业的基本条件 苹果电脑和特殊访问工具.mp4", "title": "做副业的两个基本条件一台Mac和一个上网工具", "success": false, "status": "error", "message": "Cookie 已过期", "elapsed_sec": 0.22334694862365723, "timestamp": "2026-03-20 05:39:50"}
{"platform": "抖音", "video_path": "/Users/karuo/Movies/soul视频/soul 派对 120场 20260320_output/成片/切片分发全自动化 从视频到发布一键完成.mp4", "title": "从录制到发布全自动化,一键切片分发五大平台", "success": false, "status": "error", "message": "Cookie 已过期", "elapsed_sec": 0.1871330738067627, "timestamp": "2026-03-20 05:39:54"}
{"platform": "抖音", "video_path": "/Users/karuo/Movies/soul视频/soul 派对 120场 20260320_output/成片/创业团队4人平分25有啥危险 先跑钱再谈股权.mp4", "title": "创业团队4人平分25%股权有啥风险?先跑出收入再谈分配", "success": false, "status": "error", "message": "Cookie 已过期", "elapsed_sec": 0.19080185890197754, "timestamp": "2026-03-20 05:39:57"}
{"platform": "抖音", "video_path": "/Users/karuo/Movies/soul视频/soul 派对 120场 20260320_output/成片/坚持到120场是什么感觉 方向越确定执行越坚决.mp4", "title": "坚持到第120场派对是什么感觉方向越清晰执行越坚决", "success": false, "status": "error", "message": "Cookie 已过期", "elapsed_sec": 0.45436811447143555, "timestamp": "2026-03-20 05:40:00"}
{"platform": "抖音", "video_path": "/Users/karuo/Movies/soul视频/soul 派对 120场 20260320_output/成片/帮人装AI一单300到1000块传统行业也能做.mp4", "title": "帮传统行业的人装AI工具一单收300到1000块简单好做", "success": false, "status": "error", "message": "Cookie 已过期", "elapsed_sec": 0.18743586540222168, "timestamp": "2026-03-20 05:40:03"}
{"platform": "抖音", "video_path": "/Users/karuo/Movies/soul视频/soul 派对 120场 20260320_output/成片/深度AI模型对比 哪个才是真正的AI不是语言模型.mp4", "title": "深度对比各大AI模型哪个才是真正的智能而不只是语言模型", "success": false, "status": "error", "message": "Cookie 已过期", "elapsed_sec": 0.21168994903564453, "timestamp": "2026-03-20 05:40:07"}
{"platform": "抖音", "video_path": "/Users/karuo/Movies/soul视频/soul 派对 120场 20260320_output/成片/疗愈师配AI助手能收多少钱 一个小团队5万到10万.mp4", "title": "疗愈师+AI助手组合一个小团队月收5万到10万", "success": false, "status": "error", "message": "Cookie 已过期", "elapsed_sec": 0.18154072761535645, "timestamp": "2026-03-20 05:40:10"}
{"platform": "抖音", "video_path": "/Users/karuo/Movies/soul视频/soul 派对 120场 20260320_output/成片/赚钱没那么复杂,自信心才是核心问题.mp4", "title": "获得收益真没那么复杂,自信心才是卡住你的核心问题", "success": false, "status": "error", "message": "Cookie 已过期", "elapsed_sec": 0.19428515434265137, "timestamp": "2026-03-20 05:40:13"}

View File

@@ -0,0 +1,70 @@
#!/bin/bash
# 等待127和128场切片完成然后自动分发
DIST_SCRIPT="/Users/karuo/Documents/个人/卡若AI/03_卡木/木叶_视频内容/多平台分发/脚本"
VIDEO_DIR_127="/Users/karuo/Movies/soul视频/原视频/第127场_20260318_output"
VIDEO_DIR_128="/Users/karuo/Movies/soul视频/原视频/第128场_20260319_output"
echo "等待127和128场切片完成..."
# 检查成片目录是否存在且有mp4文件
check_complete() {
local dir=$1
local session=$2
if [ -d "$dir/成片" ] || [ -d "$dir/clips_enhanced" ]; then
local clips_dir="$dir/成片"
[ ! -d "$clips_dir" ] && clips_dir="$dir/clips_enhanced"
if [ -f "$clips_dir/目录索引.md" ] && [ $(find "$clips_dir" -name "*.mp4" | wc -l) -gt 0 ]; then
echo "$session 场切片完成"
return 0
fi
fi
return 1
}
# 轮询检查
while true; do
complete_127=false
complete_128=false
check_complete "$VIDEO_DIR_127" "127" && complete_127=true
check_complete "$VIDEO_DIR_128" "128" && complete_128=true
if [ "$complete_127" = true ] && [ "$complete_128" = true ]; then
echo ""
echo "=========================================="
echo "127和128场切片全部完成开始分发..."
echo "=========================================="
# 分发127场
if [ -d "$VIDEO_DIR_127/成片" ]; then
echo "分发127场..."
cd "$DIST_SCRIPT"
python3 distribute_all.py --video-dir "$VIDEO_DIR_127/成片" --platforms 抖音 B站 小红书 --now
elif [ -d "$VIDEO_DIR_127/clips_enhanced" ]; then
echo "分发127场..."
cd "$DIST_SCRIPT"
python3 distribute_all.py --video-dir "$VIDEO_DIR_127/clips_enhanced" --platforms 抖音 B站 小红书 --now
fi
# 分发128场
if [ -d "$VIDEO_DIR_128/成片" ]; then
echo "分发128场..."
cd "$DIST_SCRIPT"
python3 distribute_all.py --video-dir "$VIDEO_DIR_128/成片" --platforms 抖音 B站 小红书 --now
elif [ -d "$VIDEO_DIR_128/clips_enhanced" ]; then
echo "分发128场..."
cd "$DIST_SCRIPT"
python3 distribute_all.py --video-dir "$VIDEO_DIR_128/clips_enhanced" --platforms 抖音 B站 小红书 --now
fi
echo ""
echo "✅ 127和128场分发完成"
break
else
echo -n "."
sleep 30
fi
done

View File

@@ -32,6 +32,7 @@
| MCP/连接MCP | `02_卡人/水桥_平台对接/MCP管理/SKILL.md` |
| Soul运营报表 | `02_卡人/水桥_平台对接/飞书管理/运营报表_SKILL.md` |
| 项目管理/卡若创业派对 | `02_卡人/水岸_项目管理/SKILL.md` |
| 聊天记录/对话存储/聊天归档 | `01_卡资/金仓_存储备份/聊天记录管理/SKILL.md` |
## 四、MAX Mode默认
@@ -60,7 +61,9 @@
## 六、记忆
- **检索顺序**:① CURRENT_STATE.md → ② 任务结果卡 structured/tasks/ → ③ 记忆.md → ④ daily_digest + agent_results → ⑤ 对话归档 archive/
- **检索顺序**:① CURRENT_STATE.md → ② 任务结果卡 structured/tasks/ → ③ 记忆.md → ④ **MongoDB 记忆条目**karuo_site.记忆条目,按分类/标签/关键词/最近 N 条调取;**不可用时 query_memory 自动降级为读 记忆.md**)→ ⑤ daily_digest + agent_results → ⑥ **对话归档**MongoDB 对话记录/消息内容,**实时从 MongoDB 读取**;不可用时用最近对话本地 fallback archive/
- **卡若 AI 唯一数据库**:本机调用一律使用 **karuo_site**(唯一 MongoDB 27017含记忆条目、对话记录、消息内容等聊天记录不依赖 Cursor 本地库,以 MongoDB 为主、归档后同步写 fallback。
- **MongoDB 记忆**:记忆.md 可同步至唯一 MongoDB`python3 记忆系统/sync_memory_to_mongo.py`);对话中快速调取用 `python3 记忆系统/query_memory.py --最近 20``--关键词 xxx``--分类 固定偏好`。详见自动记忆管理 SKILL。
- **写入前冲突检测**`python memory_conflict_check.py "内容"`
- **记忆路径**`/Users/karuo/Documents/个人/1、卡若本人/记忆.md`(单文件,以卡若角色参与)

View File

@@ -1,7 +1,7 @@
# 卡若AI 技能注册表Skill Registry
> **一张表查所有技能**。任何 AI 拿到这张表,就能按关键词找到对应技能的 SKILL.md 路径并执行。
> 74 技能 | 15 成员 | 5 负责人
> 75 技能 | 15 成员 | 5 负责人
> 版本5.5 | 更新2026-03-13
>
> **技能配置、安装、删除、掌管人登记** → 见 **`运营中枢/工作台/01_技能控制台.md`**。
@@ -74,6 +74,7 @@
| G17 | 数据库管理(安全) | 金盾 | 数据库、备份数据 | `01_卡资/金盾_数据安全/数据库管理/SKILL.md` | 数据库安全与备份 |
| G18 | 微信管理(安全) | 金盾 | 微信数据库解析 | `01_卡资/金盾_数据安全/微信管理/SKILL.md` | 微信数据库解密与分析 |
| G19 | 存客宝副本管理 | 金盾 | 存客宝副本、cunkebao_副本、存客宝开发文档、副本代码管理 | 副本项目内 `cunkebao_副本/.cursor/skills/存客宝副本管理/SKILL.md`(以副本为主,路径见下) | 存客宝副本代码与开发文档管理Skill 已迁入副本项目内 |
| G22 | **聊天记录管理** | 金仓 | **聊天记录、对话存储、聊天归档、聊天导出、聊天导入、清理聊天、对话查询、历史对话、state.vscdb、bubbleId、cursor聊天、对话迁移、聊天分类** | `01_卡资/金仓_存储备份/聊天记录管理/SKILL.md` | Cursor 聊天记录→MongoDB 分类存储+查询+导入导出+安全清理 |
## 水组 · 卡人(信息流程调度)
@@ -168,6 +169,7 @@
| F13 | 卡若日记写作 | 火种 | 日记、写日记 | `04_卡火/火种_知识模型/卡若日记写作/SKILL.md` | 每日日记自动生成 |
| G19 | Vercel部署 | 金盾 | Vercel、v0 | `01_卡资/金盾_数据安全/Vercel与v0部署流水线/SKILL.md` | Vercel/v0 一键部署 |
| G21 | 端口登记 | 工作台 | **端口登记、端口注册、部署端口、查端口、避免端口冲突、端口冲突、本机端口** | `运营中枢/工作台/端口登记/SKILL.md` | 本机 Docker/服务端口统一登记,部署前必查防重复;**放在卡若AI 底下,不放在 Cursor** |
| 卡罗帮 | **专注静默** | 工作台 | **专注、番茄钟、静默专注、开始专注、WebPomodoro、专注轻探、不打开界面计时** | `运营中枢/工作台/卡罗帮/专注静默_SKILL.md` | 不打开 WebPomodoro 界面,用 pomodoro_silent.py 静默计时 |
| G20 | 个人档案生成器 | 金盾 | 个人档案 | `01_卡资/金盾_数据安全/个人档案生成器/SKILL.md` | 安全视角的个人档案 |
| M06 | 前端生成 | 木果 | 前端生成、UI | `03_卡木/木果_项目模板/前端生成/SKILL.md` | 快速生成前端页面 |
@@ -177,9 +179,9 @@
| 组 | 负责人 | 成员数 | 技能数 |
|:--|:---|:--|:--|
| 金 | 卡资 | 2 | 21 |
| 金 | 卡资 | 2 | 22 |
| 水 | 卡人 | 4 | 14 |
| 木 | 卡木 | 3 | 14 |
| 火 | 卡火 | 4 | 16 |
| 土 | 卡土 | 4 | 9 |
| **合计** | **5** | **15** | **74** |
| **合计** | **5** | **15** | **75** |

View File

@@ -0,0 +1 @@
placeholder

View File

@@ -0,0 +1,153 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""打包 Soul 运营全链路SKILL + 脚本 + Cursor 入口,供复制到另一台电脑。"""
from __future__ import annotations
import os
import shutil
import sys
import zipfile
from pathlib import Path
KARUO_AI = Path("/Users/karuo/Documents/个人/卡若AI")
CURSOR_SKILLS = Path("/Users/karuo/.cursor/skills")
# 用户要求:压缩包放到「下载」
DOWNLOADS = Path.home() / "Downloads"
STAMP = "20260320"
BUNDLE_NAME = f"Soul运营全链路技能包_{STAMP}"
# 工作区内临时目录(便于 Cursor 写入),最终 zip 放 Downloads
WORK_ROOT = KARUO_AI / "_Soul运营技能包导出" / BUNDLE_NAME
def ignore_common(dir_name: str, names: list[str]) -> set[str]:
ignored = set()
for n in names:
if n == "__pycache__" or n.endswith(".pyc") or n == ".DS_Store":
ignored.add(n)
return ignored
def copytree(src: Path, dst: Path) -> None:
if not src.exists():
print(f"SKIP missing: {src}", file=sys.stderr)
return
dst.parent.mkdir(parents=True, exist_ok=True)
shutil.copytree(src, dst, dirs_exist_ok=True, ignore=ignore_common)
def main() -> int:
if not KARUO_AI.is_dir():
print(f"ERROR: 卡若AI 不存在: {KARUO_AI}", file=sys.stderr)
return 1
if WORK_ROOT.exists():
shutil.rmtree(WORK_ROOT)
WORK_ROOT.mkdir(parents=True, exist_ok=True)
# 目录结构:与另一台机合并到 卡若AI 时路径一致
cursor_dst = WORK_ROOT / ".cursor" / "skills"
cursor_dst.mkdir(parents=True, exist_ok=True)
for name in ("soul-operation-report", "soul-party-project"):
s = CURSOR_SKILLS / name
if s.is_dir():
copytree(s, cursor_dst / name)
kai = WORK_ROOT / "卡若AI"
# 水岸
copytree(
KARUO_AI / "02_卡人" / "水岸_项目管理",
kai / "02_卡人" / "水岸_项目管理",
)
# 水桥飞书、妙记、Soul创业实验
base_water = KARUO_AI / "02_卡人" / "水桥_平台对接"
for sub in ("飞书管理", "智能纪要", "Soul创业实验"):
copytree(base_water / sub, kai / "02_卡人" / "水桥_平台对接" / sub)
# 木叶:切片、分发、各平台
base_wood = KARUO_AI / "03_卡木" / "木叶_视频内容"
wood_dst = kai / "03_卡木" / "木叶_视频内容"
for sub in (
"视频切片",
"多平台分发",
"抖音发布",
"B站发布",
"视频号发布",
"小红书发布",
"快手发布",
):
copytree(base_wood / sub, wood_dst / sub)
# 凭证索引(另一台机需核对敏感信息)
idx = KARUO_AI / "运营中枢" / "工作台" / "00_账号与API索引.md"
if idx.is_file():
(kai / "运营中枢" / "工作台").mkdir(parents=True, exist_ok=True)
shutil.copy2(idx, kai / "运营中枢" / "工作台" / idx.name)
readme = WORK_ROOT / "解压后必读.md"
readme.write_text(
"""# Soul 运营全链路技能包 — 解压后必读
## 本包包含
- `.cursor/skills/``soul-operation-report`、`soul-party-project`Cursor 入口)
- `卡若AI/02_卡人/水岸_项目管理/`:项目管理中枢 + 卡若创业派对 README
- `卡若AI/02_卡人/水桥_平台对接/飞书管理/`:运营报表、妙记相关脚本与 SKILL
- `卡若AI/02_卡人/水桥_平台对接/智能纪要/`
- `卡若AI/02_卡人/水桥_平台对接/Soul创业实验/`:写作/上传文档与说明
- `卡若AI/03_卡木/木叶_视频内容/`:视频切片、多平台分发、各平台发布 SKILL+脚本
- `卡若AI/运营中枢/工作台/00_账号与API索引.md`:凭证速查(若源机有则已打包)
## 在另一台电脑上「可直接运作」的步骤
1. **解压**到任意位置(例如桌面)。
2. **合并到本机卡若AI根目录**(与现有一致的路径):
- 将包内 `卡若AI/` 下所有文件夹 **合并复制** 到:
`你的卡若AI根目录/`(例如 `~/Documents/个人/卡若AI/`
覆盖时请先备份同名目录,避免误删你本机独有文件。
3. **安装 Cursor 入口 Skill**(可选但推荐):
- 将 `.cursor/skills/soul-operation-report`、`soul-party-project` 复制到本机 `~/.cursor/skills/`。
4. **环境依赖**(脚本跑通需要):
- Python 3.10+、`pip` 依赖见各子目录 README / SKILL 内说明
- 视频:`FFmpeg`、`conda` 环境 `mlx-whisper`(见视频切片 SKILL
- **永平项目**:文章上传/推送需在 `一场soul的创业实验-永平` 仓库配置 `.env`、数据库等(见 `Soul创业实验/上传/环境与TOKEN配置.md`
5. **凭证**:飞书 AppSecret、妙记 Cookie、各平台 Cookie、小程序与 API 等,必须在目标机上按 `00_账号与API索引.md` 与各脚本说明 **重新配置或从安全渠道拷贝**;未配置时脚本会报错属正常。
6. **绝对路径**:部分文档或脚本内可能含原机路径(如 `/Users/karuo/...`),到新电脑请按 SKILL 内说明改为本机路径。
## 安全提示
- 压缩包内可能含 **Token/Cookie/密钥说明**,请勿上传到公开网盘;传输用加密渠道或 U 盘。
---
打包脚本:`卡若AI/_Soul运营技能包导出/build_soul_skill_bundle.py`
""",
encoding="utf-8",
)
# 清理包内 __pycache__
for p in WORK_ROOT.rglob("__pycache__"):
if p.is_dir():
shutil.rmtree(p, ignore_errors=True)
for p in WORK_ROOT.rglob("*.pyc"):
try:
p.unlink()
except OSError:
pass
DOWNLOADS.mkdir(parents=True, exist_ok=True)
zip_path = DOWNLOADS / f"{BUNDLE_NAME}.zip"
with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
for f in WORK_ROOT.rglob("*"):
if f.is_file():
arc = f.relative_to(WORK_ROOT.parent)
zf.write(f, arc.as_posix())
# 同时在工作区留一份未压缩目录,方便检查
size_mb = zip_path.stat().st_size / (1024 * 1024)
print(f"OK zip -> {zip_path} ({size_mb:.2f} MB)")
print(f"DIR -> {WORK_ROOT}")
return 0
if __name__ == "__main__":
raise SystemExit(main())

View File

@@ -8,15 +8,17 @@
**卡若AI 所有对话的 AI 回复一律采用「复盘形式」**,只有一种格式:完整复盘,每轮/每步均以完整复盘块收尾。
## 13.2 五块结构
## 13.2 五块结构(每块必带图标)
| 块 | 图标 | 内容 | 要求 |
|:--|:--:|:---|:---|
| 目标·结果·达成率 | 🎯 | 做什么、结果如何、达成百分比 | 整行 ≤30 字 |
| 过程 | 📌 | 1、2、3 分点简述执行过程 | 不用表格 |
| 反思 | 💡 | 可复用点、改进点 | 13 点 |
| 总结 | 📝 | 一两句结论或经验 | 简洁 |
| 下一步执行 | ▶ | 结合项目目标的后续动作 | 关联未完成项 |
书写时**每块标题必须带图标 + 粗体**,例如:**🎯 目标·结果·达成率**、**📌 过程**、**💡 反思**、**📝 总结**、**▶ 下一步执行**。
| 顺序 | 图标 | 块标题 | 内容 | 要求 |
|:---:|:---:|:---|:---|:---|
| 1 | 🎯 | **目标·结果·达成率** | 做什么、结果如何、达成百分比 | 整行 ≤30 字 |
| 2 | 📌 | **过程** | 1、2、3 分点简述执行过程 | 不用表格 |
| 3 | 💡 | **反思** | 可复用点、改进点 | 13 点 |
| 4 | 📝 | **总结** | 一两句结论或经验 | 简洁 |
| 5 | ▶ | **下一步执行** | 结合项目目标的后续动作 | 关联未完成项 |
## 13.3 格式要求
@@ -25,27 +27,27 @@
- **复盘块内不用表格**
- 每块用小图标标识(🎯📌💡📝▶)
## 13.4 示例
## 13.4 示例(每块带图标 + 粗体)
```markdown
**[卡若复盘]2026-03-12 10:30**
🎯 目标·结果·达成率
**🎯 目标·结果·达成率**
完善使用手册架构 · 已完成6篇24章 · 100%
📌 过程
**📌 过程**
1. 分析现有手册结构,确认缺失内容
2. 设计6篇24章目录结构
3. 逐章编写并建立导航链接
💡 反思
**💡 反思**
1. 多文件结构比单文件更易维护
2. 每章独立可以按需更新而不影响其他章节
📝 总结
**📝 总结**
使用手册从 v1.0 升级到 v2.0 书籍结构,覆盖全部功能。
▶ 下一步执行
**▶ 下一步执行**
- 持续按对话沉淀规则更新手册
- 有新技能时同步更新对应章节
```

View File

@@ -74,6 +74,24 @@ UnifiedLLM API 网关:更好价格、更稳、无需订阅,只需把模型
3. **切换 Base URL**:可尝试改为不带 `/v1``https://api123.icu`,保存后重启 Claude Code 再试。
4. **官方教程**:按 [api123.icu/about](https://api123.icu/about) 的「Claude Code CLI」教程逐步检查可联系技术 QQ 获取图文教程)。
## 若出现 503 / model_not_foundNo available channel for model … under group default
说明中转端当前对「默认分组」没有该模型通道或通道暂时不可用。**优先用一键脚本修复**
- **一键修复(推荐)**:在终端执行
`bash "卡若AI/运营中枢/参考资料/scripts/fix_claude_503.sh"`
(本机或阿猫 Mac 均可iCloud 同步后路径可能为 `婼瑄/卡若AI/...`
执行后**完全退出 Claude Code**esc 或 Cmd+C再重新打开终端执行 `claude`
若不用脚本,可手动:
1. **切到备选模型**:在 `~/.claude/settings.json` 里把 `model``env.ANTHROPIC_MODEL` 改为 api123 支持的其它模型,例如:
- `claude-sonnet-4-5-20250929`Sonnet 4.5
- `claude-haiku-4-5-20251001`Haiku成本低
保存后**完全退出 Claude Code 再重新打开**。
2. **确认 api123 控制台**:登录 api123.icu 查看当前套餐/分组下哪些模型可用,若 `claude-sonnet-4-6` 未开通可改用上列备选或联系客服开通。
3. **临时用官方源排查**:若需确认是否为中转问题,可临时把 Base URL 与 Key 改回 Anthropic 官方,仅作对比测试。
---
## 三、卡若AI网站接入信息

View File

@@ -1,13 +1,22 @@
#!/usr/bin/env bash
# Cursor 缓存清理(轻量版)—— 深度修复请用 cursor_deep_fix.sh
# 使用:完全退出 Cursor 后执行
# 使用:完全退出 Cursor 后执行。若需在 Cursor 未退出时强制清理SKIP_CURSOR_CHECK=1 bash 本脚本
set -e
CURSOR_SUPPORT="$HOME/Library/Application Support/Cursor"
if pgrep -f "Cursor.app" >/dev/null 2>&1; then
echo "⚠️ Cursor 正在运行,请先 Cmd+Q 完全退出后再执行。"
exit 1
# ── 未跳过检查时:若 Cursor 在运行则先强制退出 Cursor 及所有相关进程 ──
if [ -z "${SKIP_CURSOR_CHECK:-}" ] && pgrep -f "Cursor" >/dev/null 2>&1; then
echo "🛑 检测到 Cursor 正在运行,正在强制退出 Cursor 及相关进程..."
killall Cursor 2>/dev/null || true
sleep 3
pkill -9 -f "Cursor" 2>/dev/null || true
sleep 2
if pgrep -f "Cursor" >/dev/null 2>&1; then
echo "⚠️ Cursor 仍在运行,请从「活动监视器」手动结束,或执行: SKIP_CURSOR_CHECK=1 bash \"$0\""
exit 1
fi
echo " ✅ Cursor 已退出,继续执行..."
fi
echo "🧹 清理 Cursor GPUCache / Cache / CachedData..."

View File

@@ -0,0 +1,123 @@
#!/usr/bin/env bash
# Cursor ai-code-tracking.db 清理脚本
# 用途:清理膨胀的 ai-code-tracking.db当前 1.0GB358万行
# 使用Cmd+Q 完全退出 Cursor → 执行本脚本 → 重新打开 Cursor
#
# 清理内容:
# 1. ai_code_hashes — 代码哈希表358万行可清理旧数据
# 2. scored_commits — 已评分提交(保留最近 1000 条)
# 3. VACUUM 压缩数据库
#
# 保留内容:
# - conversation_summaries — 对话摘要(保留)
# - tracking_state — 跟踪状态(保留)
set -euo pipefail
AI_TRACKING_DB="$HOME/.cursor/ai-tracking/ai-code-tracking.db"
TRASH_DIR="$HOME/.Trash/cursor_ai_tracking_$(date +%Y%m%d_%H%M%S)"
# ── 若 Cursor 在运行则先强制退出 Cursor 及所有相关进程 ──
if pgrep -f "Cursor" >/dev/null 2>&1; then
echo "🛑 检测到 Cursor 正在运行,正在强制退出 Cursor 及相关进程..."
killall Cursor 2>/dev/null || true
sleep 3
pkill -9 -f "Cursor" 2>/dev/null || true
sleep 2
if pgrep -f "Cursor" >/dev/null 2>&1; then
echo "⚠️ 无法完全退出,请从「活动监视器」中手动结束所有 Cursor 相关进程后重试。"
exit 1
fi
echo " ✅ Cursor 已退出,继续执行..."
fi
if [ ! -f "$AI_TRACKING_DB" ]; then
echo "❌ 未找到 ai-code-tracking.db$AI_TRACKING_DB"
exit 1
fi
echo "═══════════════════════════════════════════════"
echo "🔬 Cursor ai-code-tracking.db 清理"
echo "═══════════════════════════════════════════════"
echo ""
# ── 清理前统计 ──
BEFORE_SIZE=$(du -m "$AI_TRACKING_DB" | awk '{print $1}')
echo "📊 清理前状态:"
echo " ai-code-tracking.db: ${BEFORE_SIZE} MB"
# 统计各表行数
AI_HASHES_COUNT=$(sqlite3 "$AI_TRACKING_DB" "SELECT COUNT(*) FROM ai_code_hashes;" 2>/dev/null || echo "0")
SCORED_COMMITS_COUNT=$(sqlite3 "$AI_TRACKING_DB" "SELECT COUNT(*) FROM scored_commits;" 2>/dev/null || echo "0")
CONV_SUMMARIES_COUNT=$(sqlite3 "$AI_TRACKING_DB" "SELECT COUNT(*) FROM conversation_summaries;" 2>/dev/null || echo "0")
echo " ai_code_hashes : $AI_HASHES_COUNT 行(将清理)"
echo " scored_commits : $SCORED_COMMITS_COUNT 行(保留最近 1000 条)"
echo " conversation_summaries: $CONV_SUMMARIES_COUNT 行(保留)"
echo ""
# ── 确认 ──
echo "📋 本次操作:"
echo " 🗑️ 清理ai_code_hashes 全部数据358万行可重建"
echo " 🗑️ 清理scored_commits 旧数据(保留最近 1000 条)"
echo " ✅ 保留conversation_summaries对话摘要"
echo " ✅ 保留tracking_state跟踪状态"
echo " 🔧 执行VACUUM压缩数据库回收空间"
echo ""
read -p "确认执行?(y/N) " confirm
if [ "$confirm" != "y" ] && [ "$confirm" != "Y" ]; then
echo "已取消。"
exit 0
fi
echo ""
# ── Step 1: 清理 ai_code_hashes全部删除Cursor 会按需重建) ──
echo "🧹 Step 1/3: 清理 ai_code_hashes 表..."
sqlite3 "$AI_TRACKING_DB" "DELETE FROM ai_code_hashes;" 2>&1
echo " ✅ 已清空 ai_code_hashes${AI_HASHES_COUNT} 行)"
# ── Step 2: 清理 scored_commits 旧数据(保留最近 1000 条) ──
if [ "$SCORED_COMMITS_COUNT" -gt 1000 ]; then
echo "🧹 Step 2/3: 清理 scored_commits 旧数据(保留最近 1000 条)..."
sqlite3 "$AI_TRACKING_DB" "
DELETE FROM scored_commits
WHERE id NOT IN (
SELECT id FROM scored_commits
ORDER BY id DESC
LIMIT 1000
);
" 2>&1
REMAINING=$(sqlite3 "$AI_TRACKING_DB" "SELECT COUNT(*) FROM scored_commits;" 2>/dev/null || echo "0")
echo " ✅ 已清理 scored_commits保留 $REMAINING 条)"
else
echo "🧹 Step 2/3: scored_commits 仅 $SCORED_COMMITS_COUNT 条,无需清理"
fi
# ── Step 3: VACUUM 压缩数据库 ──
echo "🔧 Step 3/3: VACUUM 压缩数据库(可能需要 30-60 秒)..."
sqlite3 "$AI_TRACKING_DB" "VACUUM;" 2>&1
echo " ✅ VACUUM 完成"
# ── 清理后统计 ──
AFTER_SIZE=$(du -m "$AI_TRACKING_DB" | awk '{print $1}')
SAVED=$((BEFORE_SIZE - AFTER_SIZE))
AFTER_AI_HASHES=$(sqlite3 "$AI_TRACKING_DB" "SELECT COUNT(*) FROM ai_code_hashes;" 2>/dev/null || echo "0")
AFTER_SCORED=$(sqlite3 "$AI_TRACKING_DB" "SELECT COUNT(*) FROM scored_commits;" 2>/dev/null || echo "0")
echo ""
echo "═══════════════════════════════════════════════"
echo "✅ 清理完成!"
echo ""
echo "📊 对比:"
echo " 清理前 ai-code-tracking.db: ${BEFORE_SIZE} MB"
echo " 清理后 ai-code-tracking.db: ${AFTER_SIZE} MB"
echo " 释放空间 : ≈${SAVED} MB"
echo ""
echo "📋 数据确认:"
echo " ai_code_hashes 行数 : $AFTER_AI_HASHES已清空Cursor 按需重建)"
echo " scored_commits 行数 : $AFTER_SCORED(保留)"
echo ""
echo "🔑 下一步:"
echo " 1. 打开 Cursor正常使用即可"
echo " 2. ai_code_hashes 会在需要时自动重建"
echo "═══════════════════════════════════════════════"

View File

@@ -0,0 +1,65 @@
#!/usr/bin/env bash
# 清理 ai-code-tracking.db 中超过 N 天的旧数据(保留最近数据)
# 使用bash cursor_clean_ai_tracking_old.sh [保留天数默认30]
set -euo pipefail
DB="$HOME/.cursor/ai-tracking/ai-code-tracking.db"
DAYS_TO_KEEP=${1:-30} # 默认保留 30 天
if [ ! -f "$DB" ]; then
echo "❌ 未找到数据库:$DB"
exit 1
fi
# 检查 Cursor 是否在运行
if pgrep -f "Cursor" >/dev/null 2>&1; then
echo "⚠️ Cursor 正在运行,请先 Cmd+Q 退出 Cursor 后执行"
exit 1
fi
echo "═══════════════════════════════════════════════"
echo "🧹 清理 ai-code-tracking.db 旧数据"
echo "═══════════════════════════════════════════════"
echo ""
BEFORE_SIZE=$(du -m "$DB" | awk '{print $1}')
BEFORE_ROWS=$(sqlite3 "$DB" "SELECT COUNT(*) FROM ai_code_hashes;" 2>/dev/null || echo "0")
echo "📊 清理前状态:"
echo " 文件大小: ${BEFORE_SIZE} MB"
echo " 总行数: ${BEFORE_ROWS:,}"
echo " 保留天数: ${DAYS_TO_KEEP}"
echo ""
# 计算保留时间戳N 天前)
CUTOFF_TS=$(python3 -c "import time; print(int((time.time() - $DAYS_TO_KEEP * 86400) * 1000))")
echo "🧹 正在清理超过 ${DAYS_TO_KEEP} 天的旧数据..."
DELETED=$(sqlite3 "$DB" "
DELETE FROM ai_code_hashes
WHERE createdAt < $CUTOFF_TS;
SELECT changes();
" 2>&1)
echo "🔧 正在压缩数据库VACUUM..."
sqlite3 "$DB" "VACUUM;" 2>&1
AFTER_SIZE=$(du -m "$DB" | awk '{print $1}')
AFTER_ROWS=$(sqlite3 "$DB" "SELECT COUNT(*) FROM ai_code_hashes;" 2>/dev/null || echo "0")
SAVED=$((BEFORE_SIZE - AFTER_SIZE))
SAVED_ROWS=$((BEFORE_ROWS - AFTER_ROWS))
echo ""
echo "═══════════════════════════════════════════════"
echo "✅ 清理完成!"
echo ""
echo "📊 对比:"
echo " 清理前: ${BEFORE_SIZE} MB (${BEFORE_ROWS:,} 行)"
echo " 清理后: ${AFTER_SIZE} MB (${AFTER_ROWS:,} 行)"
echo " 删除行数: ${SAVED_ROWS:,}"
echo " 释放空间: ${SAVED} MB"
echo ""
echo "🔑 下一步:"
echo " 重新打开 Cursor 即可正常使用"
echo "═══════════════════════════════════════════════"

View File

@@ -2,16 +2,28 @@
# Cursor 深度修复脚本(解决反复崩溃 / code 5 / Reopen 弹窗)
# 使用Cmd+Q 完全退出 Cursor → 执行本脚本 → 重新打开 Cursor
# 说明见:运营中枢/参考资料/Cursor闪退排查_20260304.md
#
# ⚠️ 重要:本脚本会移走整个 state.vscdb当 >200MB 时),
# 因此会清掉【所有 Agent 列表】和【所有聊天对话记录】。
# 若不能接受丢失对话,请改用 cursor_slim_db.sh只清缓存保留全部对话
set -euo pipefail
CURSOR_SUPPORT="$HOME/Library/Application Support/Cursor"
TRASH_DIR="$HOME/.Trash/cursor_cleanup_$(date +%Y%m%d_%H%M%S)"
# ── 检查 Cursor 是否在运行 ──
if pgrep -f "Cursor.app" >/dev/null 2>&1; then
echo "⚠️ Cursor 正在运行!请先 Cmd+Q 完全退出后再执行。"
exit 1
# ── Cursor 在运行则先强制退出 Cursor 及所有相关进程 ──
if pgrep -f "Cursor" >/dev/null 2>&1; then
echo "🛑 检测到 Cursor 正在运行,正在强制退出 Cursor 及相关进程..."
killall Cursor 2>/dev/null || true
sleep 3
pkill -9 -f "Cursor" 2>/dev/null || true
sleep 2
if pgrep -f "Cursor" >/dev/null 2>&1; then
echo "⚠️ 无法完全退出,请从「活动监视器」中手动结束所有 Cursor 相关进程后重试。"
exit 1
fi
echo " ✅ Cursor 已退出,继续执行..."
fi
echo "🔧 Cursor 深度修复开始..."

View File

@@ -0,0 +1,144 @@
#!/usr/bin/env bash
# Cursor 数据库彻底修复(解决 "Blob not found" / "Internal Error"
# ────────────────────────────────────────────────────────────────
# 问题根因:
# 之前多次清理只删 agentKv:blob保留 bubbleId对话记录
# 导致 bubbleId 引用已删除的 blob → "Blob not found" → Internal Error
# bubbleId 本身也有 70 万行 / 10 GB是数据库膨胀的真正元凶
#
# 本脚本操作:
# 1. 完全清空 cursorDiskKV 表bubbleId + agentKv + 全部中间数据)
# 2. VACUUM 压缩数据库文件
# 3. 删除冗余 backup / WAL / SHM 文件
#
# 聊天记录不会真正丢失:
# 所有 Agent 对话完整记录保存在 ~/.cursor/projects/*/agent-transcripts/*.jsonl
# 清理后 Cursor UI 里旧对话会显示空/Loading但 jsonl 原文仍在
#
# 使用:直接执行,脚本会自动退出 Cursor
# ────────────────────────────────────────────────────────────────
set -euo pipefail
DB="$HOME/Library/Application Support/Cursor/User/globalStorage/state.vscdb"
DIR="$HOME/Library/Application Support/Cursor/User/globalStorage"
TS="$(date +%Y%m%dT%H%M%S)"
echo ""
echo "══════════════════════════════════════════════════════════"
echo " Cursor 数据库彻底修复"
echo " 解决 \"Blob not found\" / \"Internal Error\" 反复出现"
echo "══════════════════════════════════════════════════════════"
echo ""
# ── Step 0: 退出 Cursor ──
if pgrep -f "Cursor.app" >/dev/null 2>&1; then
echo "🛑 Step 0: 退出 Cursor..."
osascript -e 'tell application "Cursor" to quit' 2>/dev/null || true
sleep 3
if pgrep -f "Cursor.app" >/dev/null 2>&1; then
killall "Cursor" 2>/dev/null || true
sleep 2
fi
if pgrep -f "Cursor.app" >/dev/null 2>&1; then
pkill -9 -f "Cursor" 2>/dev/null || true
sleep 2
fi
if pgrep -f "Cursor.app" >/dev/null 2>&1; then
echo "⚠️ 无法退出 Cursor请手动关闭后重新执行"
exit 1
fi
echo " ✅ Cursor 已退出"
fi
if [ ! -f "$DB" ]; then
echo "❌ 未找到 state.vscdb$DB"
exit 1
fi
# ── Step 1: 瘦身前统计 ──
BEFORE_SIZE=$(du -m "$DB" | awk '{print $1}')
echo ""
echo "📊 修复前状态:"
echo " state.vscdb : ${BEFORE_SIZE} MB"
TOTAL_ROWS=$(sqlite3 "$DB" "SELECT count(*) FROM cursorDiskKV;" 2>/dev/null || echo "?")
BUBBLE_ROWS=$(sqlite3 "$DB" "SELECT count(*) FROM cursorDiskKV WHERE key LIKE 'bubbleId:%';" 2>/dev/null || echo "?")
AGENT_ROWS=$(sqlite3 "$DB" "SELECT count(*) FROM cursorDiskKV WHERE key LIKE 'agentKv:%';" 2>/dev/null || echo "?")
echo " cursorDiskKV 总行数 : $TOTAL_ROWS"
echo " bubbleId对话气泡: $BUBBLE_ROWS"
echo " agentKvAgent缓存: $AGENT_ROWS"
# 检查 agent-transcripts 备份是否存在
TRANSCRIPT_COUNT=$(find "$HOME/.cursor/projects" -name "*.jsonl" -path "*/agent-transcripts/*" 2>/dev/null | wc -l | tr -d ' ')
echo ""
echo " 📁 agent-transcripts 备份文件: $TRANSCRIPT_COUNT 个 jsonl"
echo " (所有对话原文安全保存在这些文件中)"
echo ""
# ── Step 2: 备份当前数据库(压缩备份) ──
echo "💾 Step 1/4: 备份当前数据库..."
BACKUP_PATH="$DIR/state.vscdb.pre_full_reset_$TS"
cp "$DB" "$BACKUP_PATH"
echo " 备份保存至: state.vscdb.pre_full_reset_$TS"
# ── Step 3: 清空 cursorDiskKV一次性解决所有引用断裂问题 ──
echo "🧹 Step 2/4: 清空 cursorDiskKV 表..."
sqlite3 "$DB" <<'SQL'
PRAGMA journal_mode=DELETE;
DELETE FROM cursorDiskKV;
SQL
AFTER_ROWS=$(sqlite3 "$DB" "SELECT count(*) FROM cursorDiskKV;" 2>/dev/null)
echo " ✅ cursorDiskKV 已清空(剩余 $AFTER_ROWS 行)"
# ── Step 4: 清理 ItemTable 中的大缓存条目 ──
echo "🧹 Step 3/4: 清理 ItemTable 中的大缓存..."
sqlite3 "$DB" <<'SQL'
DELETE FROM ItemTable WHERE key = 'browserAutomation.history';
DELETE FROM ItemTable WHERE key = 'aiCodeTrackingLines';
SQL
echo " ✅ 已清理 browserAutomation.history (3MB) + aiCodeTrackingLines (1.3MB)"
# ── Step 5: VACUUM 压缩 ──
echo "🔧 Step 4/4: VACUUM 压缩数据库(可能需要 1-2 分钟)..."
sqlite3 "$DB" "VACUUM;"
echo " ✅ VACUUM 完成"
# ── 清理附属文件 ──
rm -f "${DB}-wal" "${DB}-shm" 2>/dev/null
# 删除旧的冗余备份(保留本次备份和最近一次)
for old_backup in "$DIR"/state.vscdb.backup "$DIR"/state.vscdb.pre_restore_*; do
[ -f "$old_backup" ] && rm -f "$old_backup" && echo " 🗑️ 已删除旧备份: $(basename "$old_backup")"
done
# ── 修复后统计 ──
AFTER_SIZE=$(du -m "$DB" | awk '{print $1}')
SAVED=$((BEFORE_SIZE - AFTER_SIZE))
AFTER_TOTAL=$(sqlite3 "$DB" "SELECT count(*) FROM cursorDiskKV;" 2>/dev/null || echo "?")
ITEM_ROWS=$(sqlite3 "$DB" "SELECT count(*) FROM ItemTable;" 2>/dev/null || echo "?")
echo ""
echo "══════════════════════════════════════════════════════════"
echo "✅ 彻底修复完成!"
echo ""
echo "📊 对比:"
echo " 修复前 state.vscdb : ${BEFORE_SIZE} MB"
echo " 修复后 state.vscdb : ${AFTER_SIZE} MB"
echo " 释放空间 : ≈${SAVED} MB"
echo ""
echo "📋 数据确认:"
echo " cursorDiskKV 行数 : $AFTER_TOTAL已清空Cursor 按需重建)"
echo " ItemTable 行数 : $ITEM_ROWS(编辑器状态,已保留)"
echo " agent-transcripts : $TRANSCRIPT_COUNT 个 jsonl对话原文完好"
echo ""
echo "🔑 下一步:"
echo " 1. 打开 Cursor"
echo " 2. 旧 Agent 对话会显示空白/Loading —— 这是正常的"
echo " 3. 新建 Agent 对话即可正常使用,不会再报 Blob not found"
echo " 4. 如需查看旧对话内容,去 ~/.cursor/projects/*/agent-transcripts/ 看 jsonl"
echo ""
echo "⚡ 备份位置(如需回退):"
echo " $BACKUP_PATH"
echo "══════════════════════════════════════════════════════════"

View File

@@ -0,0 +1,154 @@
#!/usr/bin/env bash
# Cursor 激进清理脚本 - 一次性解决 24GB 问题
# ⚠️ 警告:本脚本会清理大量数据,请确保已备份重要对话
# 使用Cmd+Q 完全退出 Cursor → 执行本脚本 → 重新打开 Cursor
set -euo pipefail
CURSOR_SUPPORT="$HOME/Library/Application Support/Cursor"
AI_TRACKING_DB="$HOME/.cursor/ai-tracking/ai-code-tracking.db"
STATE_DB="$CURSOR_SUPPORT/User/globalStorage/state.vscdb"
SNAPSHOTS_DIR="$CURSOR_SUPPORT/snapshots"
# ── 若 Cursor 在运行则先强制退出 ──
if pgrep -f "Cursor" >/dev/null 2>&1; then
echo "🛑 检测到 Cursor 正在运行,正在强制退出..."
killall Cursor 2>/dev/null || true
sleep 3
pkill -9 -f "Cursor" 2>/dev/null || true
sleep 2
if pgrep -f "Cursor" >/dev/null 2>&1; then
echo "⚠️ 无法完全退出,请从「活动监视器」中手动结束所有 Cursor 相关进程后重试。"
exit 1
fi
echo " ✅ Cursor 已退出,继续执行..."
fi
echo "═══════════════════════════════════════════════"
echo "🔧 Cursor 激进清理(解决 24GB 问题)"
echo "═══════════════════════════════════════════════"
echo ""
# ── 统计清理前大小 ──
TOTAL_BEFORE=0
if [ -f "$STATE_DB" ]; then
STATE_SIZE=$(du -m "$STATE_DB" | awk '{print $1}')
TOTAL_BEFORE=$((TOTAL_BEFORE + STATE_SIZE))
echo "📊 state.vscdb: ${STATE_SIZE} MB"
fi
if [ -f "$AI_TRACKING_DB" ]; then
AI_SIZE=$(du -m "$AI_TRACKING_DB" | awk '{print $1}')
TOTAL_BEFORE=$((TOTAL_BEFORE + AI_SIZE))
echo "📊 ai-code-tracking.db: ${AI_SIZE} MB"
fi
if [ -d "$SNAPSHOTS_DIR" ]; then
SNAP_SIZE=$(du -sm "$SNAPSHOTS_DIR" | awk '{print $1}')
TOTAL_BEFORE=$((TOTAL_BEFORE + SNAP_SIZE))
echo "📊 snapshots/: ${SNAP_SIZE} MB"
fi
echo ""
echo "📊 总计: ${TOTAL_BEFORE} MB (约 $((TOTAL_BEFORE / 1024)) GB)"
echo ""
# ── 确认 ──
echo "⚠️ 本脚本将执行以下操作:"
echo " 1. 清空 ai-code-tracking.dbCursor 会按需重建)"
echo " 2. 清空 state.vscdb 的 cursorDiskKV对话会显示空白但 jsonl 原文保留)"
echo " 3. 删除 snapshots/ 目录(代码快照,可重建)"
echo " 4. 清理所有缓存和临时文件"
echo ""
echo "📝 注意:"
echo " - 对话原文在 ~/.cursor/projects/*/agent-transcripts/*.jsonl不会删除"
echo " - Cursor 重启后会重建必要的数据库"
echo " - 预计释放: ~${TOTAL_BEFORE} MB"
echo ""
read -p "确认执行激进清理?(y/N) " confirm
if [ "$confirm" != "y" ] && [ "$confirm" != "Y" ]; then
echo "已取消。"
exit 0
fi
echo ""
# ── Step 1: 清空 ai-code-tracking.db ──
if [ -f "$AI_TRACKING_DB" ]; then
echo "🧹 Step 1/4: 清空 ai-code-tracking.db..."
sqlite3 "$AI_TRACKING_DB" "
DELETE FROM ai_code_hashes;
DELETE FROM scored_commits WHERE id NOT IN (SELECT id FROM scored_commits ORDER BY id DESC LIMIT 100);
VACUUM;
" 2>&1
echo " ✅ ai-code-tracking.db 已清空"
fi
# ── Step 2: 清空 state.vscdb 的 cursorDiskKV ──
if [ -f "$STATE_DB" ]; then
echo "🧹 Step 2/4: 清空 state.vscdb 的 cursorDiskKV..."
sqlite3 "$STATE_DB" "
PRAGMA journal_mode=DELETE;
DELETE FROM cursorDiskKV;
DELETE FROM ItemTable WHERE key = 'browserAutomation.history';
DELETE FROM ItemTable WHERE key = 'aiCodeTrackingLines';
VACUUM;
" 2>&1
echo " ✅ state.vscdb 已清理"
fi
# ── Step 3: 删除 snapshots ──
if [ -d "$SNAPSHOTS_DIR" ]; then
echo "🧹 Step 3/4: 删除 snapshots/ 目录..."
rm -rf "$SNAPSHOTS_DIR"
mkdir -p "$SNAPSHOTS_DIR"
echo " ✅ snapshots/ 已清空"
fi
# ── Step 4: 清理缓存 ──
echo "🧹 Step 4/4: 清理缓存和临时文件..."
rm -rf "$CURSOR_SUPPORT/GPUCache" "$CURSOR_SUPPORT/Cache" "$CURSOR_SUPPORT/CachedData" 2>/dev/null || true
rm -f "$STATE_DB"-wal "$STATE_DB"-shm 2>/dev/null || true
rm -f "$STATE_DB.backup" 2>/dev/null || true
find "$CURSOR_SUPPORT/User/globalStorage" -name "state.vscdb.pre_restore_*" -delete 2>/dev/null || true
echo " ✅ 缓存已清理"
# ── 统计清理后大小 ──
TOTAL_AFTER=0
if [ -f "$STATE_DB" ]; then
STATE_SIZE=$(du -m "$STATE_DB" | awk '{print $1}')
TOTAL_AFTER=$((TOTAL_AFTER + STATE_SIZE))
fi
if [ -f "$AI_TRACKING_DB" ]; then
AI_SIZE=$(du -m "$AI_TRACKING_DB" | awk '{print $1}')
TOTAL_AFTER=$((TOTAL_AFTER + AI_SIZE))
fi
if [ -d "$SNAPSHOTS_DIR" ]; then
SNAP_SIZE=$(du -sm "$SNAPSHOTS_DIR" | awk '{print $1}')
TOTAL_AFTER=$((TOTAL_AFTER + SNAP_SIZE))
fi
SAVED=$((TOTAL_BEFORE - TOTAL_AFTER))
echo ""
echo "═══════════════════════════════════════════════"
echo "✅ 激进清理完成!"
echo ""
echo "📊 对比:"
echo " 清理前总计: ${TOTAL_BEFORE} MB (约 $((TOTAL_BEFORE / 1024)) GB)"
echo " 清理后总计: ${TOTAL_AFTER} MB"
echo " 释放空间: ${SAVED} MB (约 $((SAVED / 1024)) GB)"
echo ""
echo "🔑 下一步:"
echo " 1. 重新打开 Cursor首次启动会稍慢 10-20 秒)"
echo " 2. Cursor 会自动重建必要的数据库"
echo " 3. 旧对话显示空白是正常的jsonl 原文仍在)"
echo ""
echo "💡 预防措施:"
echo " - 建议每周执行一次清理bash cursor_clean_ai_tracking_old.sh 7"
echo " - 减少工作区数量(只保留 1-2 个)"
echo " - 定期检查数据库大小"
echo "═══════════════════════════════════════════════"

View File

@@ -1,27 +1,39 @@
#!/usr/bin/env bash
# Cursor 数据库智能瘦身(保留全部对话,只清缓存
# 效果:把 21GB 的 state.vscdb 缩到 ~10GB所有聊天记录完整保留
# Cursor 数据库智能瘦身 v2清理全部缓存 + 旧对话气泡
# 效果:把膨胀的 state.vscdb10GB+)缩到 ~50MB
# 使用Cmd+Q 完全退出 Cursor → 执行本脚本 → 重新打开 Cursor
#
# 清理内容Cursor 会自动重新生成,不影响功能):
# 1. agentKv:blob — Agent 代码分析缓存(哈希/嵌入),可再生
# 2. 中间态数据 — checkpointId / codeBlockDiff / inlineDiff 等临时数据
# 3. state.vscdb.backup — 旧备份文件15GB 冗余)
# 2. bubbleId — 对话气泡数据是膨胀主因70万行/10GB
# 3. 中间态数据 — checkpointId / codeBlockDiff / inlineDiff 等临时数据
# 4. state.vscdb.backup — 旧备份文件(冗余)
#
# 聊天记录保留方式:
# 所有 Agent 对话完整 jsonl 保存在 ~/.cursor/projects/*/agent-transcripts/
# 清理 bubbleId 后 Cursor UI 旧对话显示空白,但 jsonl 原文仍在
#
# 保留内容(绝不删除):
# - bubbleId:* — 所有聊天对话Agent 对话历史)
# - ItemTable — 编辑器全局状态
# - composerData — Composer 数据
# - composerData — Composer 数据(仅保留最近的)
set -euo pipefail
DB="$HOME/Library/Application Support/Cursor/User/globalStorage/state.vscdb"
BACKUP="$HOME/Library/Application Support/Cursor/User/globalStorage/state.vscdb.backup"
# ── 检查 Cursor 是否在运行 ──
if pgrep -f "Cursor.app" >/dev/null 2>&1; then
echo "⚠️ Cursor 正在运行!请先 Cmd+Q 完全退出后再执行。"
exit 1
# ── Cursor 在运行则先强制退出 Cursor 及所有相关进程 ──
if pgrep -f "Cursor" >/dev/null 2>&1; then
echo "🛑 检测到 Cursor 正在运行,正在强制退出 Cursor 及相关进程..."
killall Cursor 2>/dev/null || true
sleep 3
pkill -9 -f "Cursor" 2>/dev/null || true
sleep 2
if pgrep -f "Cursor" >/dev/null 2>&1; then
echo "⚠️ 无法完全退出,请从「活动监视器」中手动结束所有 Cursor 相关进程后重试。"
exit 1
fi
echo " ✅ Cursor 已退出,继续执行..."
fi
if [ ! -f "$DB" ]; then
@@ -56,10 +68,11 @@ echo ""
# ── 确认 ──
echo "📋 本次操作:"
echo " ✅ 保留:所有 bubbleId聊天对话)+ ItemTable编辑器状态+ composerData"
echo " 🗑️ 清理agentKv:blobAgent 缓存)+ checkpointId/codeBlockDiff/inlineDiff 等中间数据"
echo " 🗑️ 清理:bubbleId对话气泡,膨胀主因)+ agentKv + 全部中间数据"
echo " ✅ 保留ItemTable编辑器状态+ composerData最近的"
echo " 🗑️ 删除state.vscdb.backup冗余备份文件"
echo " 🔧 执行VACUUM压缩数据库回收空间"
echo " 📁 对话原文:保存在 ~/.cursor/projects/*/agent-transcripts/*.jsonl"
echo ""
read -p "确认执行?(y/N) " confirm
if [ "$confirm" != "y" ] && [ "$confirm" != "Y" ]; then
@@ -68,48 +81,39 @@ if [ "$confirm" != "y" ] && [ "$confirm" != "Y" ]; then
fi
echo ""
# ── Step 1: 删除 agentKv:blobAgent 缓存,可再生 ──
echo "🧹 Step 1/4: 清理 agentKv:blob 缓存数据..."
sqlite3 "$DB" "DELETE FROM cursorDiskKV WHERE key LIKE 'agentKv:blob:%';" 2>&1
AFTER_AGENT=$(sqlite3 "$DB" "SELECT count(*) FROM cursorDiskKV WHERE key LIKE 'agentKv:blob:%';" 2>/dev/null)
echo " 已清理 agentKv:blob剩余 $AFTER_AGENT"
# ── Step 1: 清空 cursorDiskKV解决 Blob not found 引用断裂 ──
echo "🧹 Step 1/2: 清空 cursorDiskKV 表..."
sqlite3 "$DB" "PRAGMA journal_mode=DELETE; DELETE FROM cursorDiskKV;" 2>&1
echo " ✅ 已清空全部 cursorDiskKV 数据"
# ── Step 2: 删除中间态临时数据(不含 bubbleId 和 composerData ──
echo "🧹 Step 2/4: 清理中间态临时数据..."
# ── Step 2: 清理 ItemTable 中的大缓存条目 ──
echo "🧹 Step 2/2: 清理 ItemTable 大缓存条目..."
sqlite3 "$DB" "
DELETE FROM cursorDiskKV WHERE key LIKE 'checkpointId:%';
DELETE FROM cursorDiskKV WHERE key LIKE 'codeBlockPartialInlineDiffFates:%';
DELETE FROM cursorDiskKV WHERE key LIKE 'codeBlockDiff:%';
DELETE FROM cursorDiskKV WHERE key LIKE 'inlineDiff:%';
DELETE FROM cursorDiskKV WHERE key LIKE 'patch-graph:%';
DELETE FROM cursorDiskKV WHERE key LIKE 'messageRequestContext:%';
DELETE FROM cursorDiskKV WHERE key LIKE 'expectedContent-v1-%';
DELETE FROM ItemTable WHERE key = 'browserAutomation.history';
DELETE FROM ItemTable WHERE key = 'aiCodeTrackingLines';
" 2>&1
AFTER_OTHER=$(sqlite3 "$DB" "SELECT count(*) FROM cursorDiskKV WHERE key NOT LIKE 'agentKv:blob:%' AND key NOT LIKE 'bubbleId:%';" 2>/dev/null)
echo " 中间态数据剩余 $AFTER_OTHER 行(保留了 composerData 等)"
echo " ✅ 已清理大缓存条目"
# ── Step 3: VACUUM 压缩数据库 ──
echo "🔧 Step 3/4: VACUUM 压缩数据库(需要一些时间,请耐心等待..."
echo "🔧 VACUUM 压缩数据库(可能需要 1-2 分钟..."
sqlite3 "$DB" "VACUUM;" 2>&1
echo " VACUUM 完成"
echo " VACUUM 完成"
# ── Step 4: 删除冗余 backup ──
if [ -f "$BACKUP" ]; then
echo "🗑️ Step 4/4: 删除冗余备份 state.vscdb.backup${BACKUP_SIZE}MB..."
rm -f "$BACKUP"
echo " 已删除"
else
echo "✅ Step 4/4: 无冗余备份文件,跳过"
fi
# 清理 WAL 和 SHMVACUUM 后这些可以删)
# ── Step 4: 清理附属文件 ──
rm -f "${DB}-wal" "${DB}-shm" 2>/dev/null
if [ -f "$BACKUP" ]; then
echo "🗑️ 删除冗余备份 state.vscdb.backup${BACKUP_SIZE}MB..."
rm -f "$BACKUP"
fi
for old_bak in "$HOME/Library/Application Support/Cursor/User/globalStorage"/state.vscdb.pre_restore_*; do
[ -f "$old_bak" ] && rm -f "$old_bak"
done
# ── 瘦身后统计 ──
AFTER_SIZE=$(du -m "$DB" | awk '{print $1}')
AFTER_TOTAL=$(sqlite3 "$DB" "SELECT count(*) FROM cursorDiskKV;" 2>/dev/null || echo "?")
AFTER_BUBBLE=$(sqlite3 "$DB" "SELECT count(*) FROM cursorDiskKV WHERE key LIKE 'bubbleId:%';" 2>/dev/null || echo "?")
SAVED=$((BEFORE_SIZE + BACKUP_SIZE - AFTER_SIZE))
TRANSCRIPT_COUNT=$(find "$HOME/.cursor/projects" -name "*.jsonl" -path "*/agent-transcripts/*" 2>/dev/null | wc -l | tr -d ' ')
echo ""
echo "═══════════════════════════════════════════════"
@@ -121,10 +125,12 @@ echo " 瘦身前 state.vscdb : ${BEFORE_SIZE} MB"
echo " 瘦身后 state.vscdb : ${AFTER_SIZE} MB"
echo " 总释放空间 : ≈${SAVED} MB"
echo ""
echo "📋 数据保留确认:"
echo " bubbleId聊天对话 : $AFTER_BUBBLE 行 ✅ 全部保留"
echo " cursorDiskKV 总行数 : $AFTER_TOTAL"
echo "📋 数据确认:"
echo " cursorDiskKV 行数 : $AFTER_TOTAL已清空Cursor 按需重建)"
echo " agent-transcripts : $TRANSCRIPT_COUNT 个 jsonl对话原文完好"
echo ""
echo "🔑 下一步:直接打开 Cursor 即可"
echo " Agent 缓存会在使用时按需重建,不影响功能)"
echo "🔑 下一步:"
echo " 1. 打开 Cursor新建 Agent 对话即可正常使用"
echo " 2. 旧对话显示空白/Loading 是正常的"
echo " 3. 对话原文在 ~/.cursor/projects/*/agent-transcripts/*.jsonl"
echo "═══════════════════════════════════════════════"

View File

@@ -0,0 +1,46 @@
#!/usr/bin/env bash
# 一键修复 Claude Code 503 / model_not_foundapi123 无 claude-sonnet-4-6 通道时)
# 用法bash 本脚本路径(本机或阿猫 Mac 均可iCloud 同步后路径可能带「婼瑄」)
# 执行后请完全退出 Claude Code 再重新打开
set -e
CLAUDE_DIR="$HOME/.claude"
SETTINGS="$CLAUDE_DIR/settings.json"
# 备选模型api123 通常可用
FALLBACK_MODEL="claude-sonnet-4-5-20250929"
BASE_URL="https://api123.icu"
API_KEY="sk-h7VW10iTSSXo6xJXe44nI1vUhsEcG3H8Z9XyFmWABvhaD4ZW"
mkdir -p "$CLAUDE_DIR"
python3 -c "
import json, os
p = '$SETTINGS'
data = {}
if os.path.exists(p):
try:
with open(p) as f:
data = json.load(f)
except Exception as e:
print('读取原配置失败,将写入新配置:', e)
data = {}
# 强制使用备选模型,避免 503
data['model'] = '$FALLBACK_MODEL'
if 'env' not in data:
data['env'] = {}
env = data['env']
env['ANTHROPIC_API_KEY'] = env.get('ANTHROPIC_API_KEY') or '$API_KEY'
env['ANTHROPIC_BASE_URL'] = env.get('ANTHROPIC_BASE_URL') or '$BASE_URL'
env['ANTHROPIC_MODEL'] = '$FALLBACK_MODEL'
# 兼容旧字段
data['anthropicBaseUrl'] = data.get('anthropicBaseUrl') or '$BASE_URL'
data['anthropicApiKey'] = data.get('anthropicApiKey') or env['ANTHROPIC_API_KEY']
data['defaultModel'] = '$FALLBACK_MODEL'
with open(p, 'w') as f:
json.dump(data, f, indent=2, ensure_ascii=False)
print('已写入:', p)
print('模型已设为:', '$FALLBACK_MODEL')
"
echo ""
echo "✅ 配置已更新为 Sonnet 4.5,可避免 503。"
echo "▶ 请完全退出 Claude Code当前窗口按 esc 或 Cmd+C然后重新打开终端执行: claude"
echo ""

View File

@@ -0,0 +1,91 @@
# 卡若AI · 每次对话逻辑(更新后)
> 记忆接入 MongoDB 后的完整流程说明。**流程图**:同目录下 **`卡若AI_每次对话逻辑_流程图.png`**(图片格式,以后流程图均按此形式提供,不再使用 HTML
---
## 一、整体逻辑概览
每次对话遵循:**启动 → 记忆与上下文加载 → 技能匹配 → 思考与拆解 → 执行与验证 → 记忆写入与同步 → 收尾**。记忆来源在「记忆.md」基础上增加了 **MongoDB 记忆条目**,可在对话中按分类/标签/关键词/最近 N 条快速调取。
---
## 二、对话开始(启动与上下文)
| 步骤 | 动作 | 说明 |
|:---|:---|:---|
| 1 | 读 BOOTSTRAP.md | 身份、团队、MAX Mode、执行流程、记忆检索顺序 |
| 2 | 读 SKILL_REGISTRY.md | 热技能速查 → 未命中则全表查技能路径 |
| 3 | 读 记忆.md | 唯一记忆源:`1、卡若本人/记忆.md`,以卡若角色参与 |
| 4 | 可选读 CURRENT_STATE.md | 当日工作台状态 |
| 5 | 按需调取 MongoDB 记忆 | 若需补充历史/偏好/规则:`query_memory.py --最近 20``--关键词 xxx``--分类 固定偏好` |
---
## 三、记忆检索顺序(更新后)
当需要「回忆」时,按以下顺序查找(先命中先使用):
1. **CURRENT_STATE.md** — 当日工作台
2. **任务结果卡** structured/tasks/
3. **记忆.md** — 长期偏好与沉淀(权威源)
4. **MongoDB 记忆条目**karuo_site.记忆条目)— 按分类/标签/日期/关键词/最近 N 条调取(`query_memory.py`**MongoDB 不可用时自动降级为读 记忆.md**
5. daily_digest + agent_results
6. **对话归档** — 一律从 **MongoDB**karuo_site.对话记录、消息内容)实时读取;上下文召回用 `context_recall.py`。**MongoDB 不可用时使用最近对话本地 fallback**(聊天记录管理/fallback/recent_chats_fallback.json
7. archive/
---
## 四、技能匹配与执行
| 步骤 | 动作 |
|:---|:---|
| 1 | 用户需求 → 热技能速查匹配;未命中 → 读 SKILL_REGISTRY 全文 |
| 2 | 命中技能 → 读对应 SKILL.md按 Steps 执行 |
| 3 | MAX Mode先思考、拆解、展示计划再执行至少两轮验证 |
| 4 | 对话中可随时按需执行 `query_memory.py` 调取记忆(不改变检索顺序,仅补充上下文) |
---
## 五、记忆写入与同步(更新后)
| 时机 | 动作 |
|:---|:---|
| 写入前 | `memory_conflict_check.py "新内容"` 冲突检测 |
| 写入 | 写入 **记忆.md**MemoryManager可选`sync_memory_to_mongo.py` 将 记忆.md 同步到 MongoDB |
| 同步 | 新条目进入 记忆.md 后,执行一次 `sync_memory_to_mongo.py` 即可在 MongoDB 中按分类/关键词查询 |
---
## 六、对话结束
- 强制复盘(🎯📌💡📝▶ 五块,带日期时间)
- **聊天归档**`auto_archive.py --scan-new` 将本轮对话写入 **MongoDB**(对话记录/消息内容),并同步写入本地 fallback供数据库不可用时召回。
- 可选sync_memory_to_mongo、Gitea 同步、飞书复盘发群等
---
## 七、MongoDB 记忆相关命令速查
| 目的 | 命令 |
|:---|:---|
| 记忆.md → MongoDB | `python3 02_卡人/水溪_整理归档/记忆系统/sync_memory_to_mongo.py` |
| 最近 N 条 | `python3 …/query_memory.py --最近 20` |
| 按分类 | `python3 …/query_memory.py --分类 固定偏好` |
| 按标签 | `python3 …/query_memory.py --标签 规则` |
| 按关键词 | `python3 …/query_memory.py --关键词 飞书` |
| 按日期 | `python3 …/query_memory.py --日期 2026-03-15` |
| 统计 | `python3 …/query_memory.py --stats` |
---
## 八、数据库与降级
- **卡若 AI 调用的数据库**:唯一 MongoDB27017库名 **karuo_site**,含:记忆条目、对话记录、消息内容等。聊天记录不存 Cursor 本地库为主,以 MongoDB 为主存储并支持实时调用。
- **记忆**query_memory 连不上 MongoDB 时,自动输出 记忆.md 最近若干行。
- **聊天**context_recall 连不上 MongoDB 时,从 `聊天记录管理/fallback/recent_chats_fallback.json` 做关键词匹配召回最近对话。
## 九、流程图文件
- **流程图**:同目录 **`卡若AI_每次对话逻辑_流程图.png`**(图片格式)。
- **约定**卡若AI 流程图一律使用**图片格式PNG**提供,不使用 HTML。

View File

@@ -0,0 +1,105 @@
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>卡若AI · 每次对话逻辑流程图</title>
<script src="https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.min.js"></script>
<style>
body {
font-family: "PingFang SC", "Microsoft YaHei", sans-serif;
margin: 24px;
background: #fafafa;
color: #1a1a1a;
}
h1 {
font-size: 1.5rem;
margin-bottom: 8px;
}
.subtitle {
color: #666;
font-size: 0.9rem;
margin-bottom: 24px;
}
.mermaid {
background: #fff;
padding: 24px;
border-radius: 8px;
box-shadow: 0 1px 3px rgba(0,0,0,0.08);
}
.note {
margin-top: 24px;
padding: 12px 16px;
background: #f0f7ff;
border-radius: 6px;
font-size: 0.85rem;
color: #333;
}
</style>
</head>
<body>
<h1>卡若AI · 每次对话逻辑流程图</h1>
<p class="subtitle">记忆接入 MongoDB 后的完整流程(更新后)</p>
<div class="mermaid">
flowchart TB
A[对话开始] --> B[读 BOOTSTRAP]
B --> C[读 SKILL_REGISTRY]
C --> D[读 记忆.md]
D --> E{需补充记忆?}
E -->|是| F[query_memory 调取 MongoDB]
E -->|否| G[技能匹配]
F --> G
G --> H[热技能速查或全表]
H --> I[读 SKILL.md]
I --> J[思考拆解 MAX Mode]
J --> K[执行]
K --> L{对话中需调取记忆?}
L -->|是| M[query_memory]
L -->|否| N[继续]
M --> N
N --> O{写入新记忆?}
O -->|是| P[冲突检测]
P --> Q[写 记忆.md]
Q --> R[可选 同步到 MongoDB]
O -->|否| S[两轮验证]
R --> S
S --> T[复盘五块]
T --> U[对话结束]
U --> V[可选 归档 Gitea 飞书]
</div>
<p style="margin-top:16px;font-weight:bold;">记忆检索顺序(按需时依次查找)</p>
<div class="mermaid">
flowchart LR
W1[CURRENT_STATE] --> W2[任务结果卡] --> W3[记忆.md] --> W4[MongoDB记忆条目] --> W5[对话归档]
</div>
<p style="margin-top:24px;font-weight:bold;">复盘五块(带图标 · 每块必写)</p>
<div class="mermaid">
flowchart LR
R1["🎯 目标·结果·达成率"] --> R2["📌 过程"] --> R3["💡 反思"] --> R4["📝 总结"] --> R5["▶ 下一步执行"]
</div>
<div class="note" style="margin-top:8px;">
<strong>复盘格式</strong>:标题 <code>[卡若复盘]YYYY-MM-DD HH:mm</code>,下接五块,每块<strong>图标 + 小标题</strong><br>
🎯 目标+结果+达成率≤30字 → 📌 过程 1 2 3 → 💡 反思 13 点 → 📝 总结 → ▶ 下一步执行(关联未完成项)。详见 <code>卡若复盘格式_固定规则.md</code>
</div>
<div class="note">
<strong>记忆检索顺序</strong>(按需时按此顺序查找):① CURRENT_STATE → ② 任务结果卡 → ③ 记忆.md → ④ MongoDB 记忆条目query_memory不可用时降级读 记忆.md→ ⑤ daily_digest / ⑥ 对话归档MongoDB 实时读,不可用时用 fallback/ archive。<br>
<strong>卡若 AI 唯一数据库</strong>karuo_site记忆条目、对话记录、消息内容。聊天记录以 MongoDB 为主、实时调用context_recall 不可用时读 fallback/recent_chats_fallback.json。
</div>
<script>
mermaid.initialize({
startOnLoad: true,
theme: 'neutral',
flowchart: {
useMaxWidth: true,
htmlLabels: true,
curve: 'basis'
}
});
</script>
</body>
</html>

Binary file not shown.

After

Width:  |  Height:  |  Size: 972 KiB

View File

@@ -4,32 +4,49 @@
---
## 五块与图标(必按此写)
复盘由 **5 块** 组成,**每块必须有对应图标 + 小标题**,顺序固定:
| 顺序 | 图标 | 块标题 | 说明 |
|:---:|:---:|:---|:---|
| 1 | 🎯 | **目标·结果·达成率** | 目标+结果+达成率 XX%,整行 ≤30 字 |
| 2 | 📌 | **过程** | 1、2、3 分点简述做了什么 |
| 3 | 💡 | **反思** | 13 点:做得好的 / 可改进的 |
| 4 | 📝 | **总结** | 一两句结论或可复用经验 |
| 5 | ▶ | **下一步执行** | 与本次任务、未完成项关联的下一步;无则写「无」 |
书写时**每块标题必须带图标**,例如:**🎯 目标·结果·达成率**、**📌 过程**、**💡 反思**、**📝 总结**、**▶ 下一步执行**。
---
## 格式(唯一 · 必填 · 带图标)
复盘**只有这一种格式**。每块**一个图标 + 小标题**便于识别;**目标·结果·达成率**整行 ≤30 字;过程/反思之间可插入流程图或图片。**禁止在复盘块内使用表格**。
```
[卡若复盘]YYYY-MM-DD HH:mm ← 强制:须填当次回复的**具体日期+具体时间**(如 2026-03-01 15:20能加颜色则用颜色标出
**复制用完整模板(标题与五块均带图标):**
🎯 目标·结果·达成率
整行不超过 30 字:目标+结果+达成率 XX%,同一行写完。多任务可拆为 1 2 3 三句,每句仍 ≤30 字。
```markdown
**[卡若复盘]YYYY-MM-DD HH:mm**
📌 过程
**🎯 目标·结果·达成率**
(整行 ≤30 字:目标+结果+达成率 XX%。多任务可拆为 1 2 3 三句,每句仍 ≤30 字。)
**📌 过程**
1. 第一步做了什么。(一句)
2. 第二步做了什么。(一句)
3. 第三步做了什么。(一句)
(可在此块与 💡 反思 之间插入流程图、示意图等。)
💡 反思
**💡 反思**
1. 做得好的或可复用的。(一句)
2. 可改进的或下次注意的。(一句)
3. 可选:结论或边界。(一句)
📝 总结
**📝 总结**
结论或可复用经验。(一两句。)
▶ 下一步执行
结合本对话与项目/卡若AI 整体目标,给出与当前任务、未完成项相关联的下一步规划;以实现目标为核心,可参考团队讨论与上下文。必须包含本对话**未完成或待跟进的文档/任务**;无则写「无」。
**▶ 下一步执行**
结合本对话与项目/卡若AI 整体目标,给出与当前任务、未完成项相关联的下一步规划;以实现目标为核心。必须包含本对话未完成或待跟进的文档/任务;无则写「无」。
```
**可选(仅当本对话涉及扫描任务时写):**

View File

@@ -44,6 +44,11 @@
若新类型出现,在本表与 `卡若Ai的文件夹/README.md` 中同步增加说明。
### 流程图与图示(强制)
- **格式**:流程图、架构图等一律使用**图片格式PNG**提供,**不使用 HTML**。
- **存放**:对外给用户的流程图存 `卡若Ai的文件夹/图片/` 并按规定登记;仓库内参考资料类流程图可放在 `运营中枢/参考资料/` 与对应说明文档同目录(如 `卡若AI_每次对话逻辑_流程图.png``卡若AI_每次对话逻辑_更新说明.md` 同目录)。
---
## 三、与「经验库」的区别

View File

@@ -100,18 +100,6 @@
| 说明 | 必须用 API 或 Web 创建仓库才能显示在界面;禁止 SSH mkdir+init推送统一用 HTTPS |
### api123.icuUnifiedLLM 中转,阿猫 Mac 默认直连)
| 项 | 值 |
| --------- | ------------------------------------------------------------------ |
| 控制台/取 Key | [https://api123.icu/console](https://api123.icu/console) |
| 使用教程 | [https://api123.icu/about](https://api123.icu/about)(图文在页面下方) |
| Base URL | `https://api123.icu`(部分客户端需 `https://api123.icu/v1`,按软件要求) |
| API Key阿猫 Mac 直连用) | `sk-h7VW10iTSSXo6xJXe44nI1vUhsEcG3H8Z9XyFmWABvhaD4ZW` |
| 默认模型 | `claude-sonnet-4-6` |
| 说明 | 阿猫 Mac 上 Cursor/Claude Code/LobeChat 等默认 API 填此 Base URL + 上表 Key详见《Claude_Code_api123配置说明》 |
---
## 二、数据库(明文)

View File

@@ -0,0 +1,87 @@
# Claude Code 配置诊断报告
> 生成时间2026-03-20
---
## 一、当前配置信息
| 配置项 | 值 |
|--------|-----|
| **配置文件路径** | `~/.claude/settings.json` |
| **API Key** | `sk-h7VW10iTSSXo6xJXe44nI1vUhsEcG3H8Z9XyFmWABvhaD4ZW` |
| **Base URL** | `https://api123.icu` |
| **默认模型** | `claude-sonnet-4-5-20250929` (Sonnet 4.5) |
| **API 服务商** | api123.icu中转服务 |
---
## 二、配置验证结果
**API 连接测试**:成功
**配置文件格式**:正确
**API Key 有效性**:已验证(测试请求成功返回)
---
## 三、已执行的修复操作
1. ✅ 已运行 `fix_claude_503.sh` 修复脚本
2. ✅ 已清理卡住的进程PID: 11144, 11125
3. ✅ 配置已更新为 `claude-sonnet-4-5-20250929`(避免 503 错误)
---
## 四、使用说明
### 4.1 如果 claude 命令仍然出错
**请完全退出 Claude Code 后重新打开**
1. 在 Claude Code 窗口中按 `Esc``Cmd+C` 完全退出
2. 关闭所有 Claude Code 相关窗口
3. 重新打开终端,执行 `claude` 命令
### 4.2 如果出现 503 或 model_not_found 错误
当前配置已使用 `claude-sonnet-4-5-20250929`Sonnet 4.5),这是 api123.icu 默认分组通常可用的模型。
如果仍出现 503可以
- 登录 [api123.icu](https://api123.icu) 控制台检查当前套餐/分组下哪些模型可用
- 或联系 api123 客服开通 `claude-sonnet-4-6` 通道
### 4.3 如果出现 401 无效令牌错误
1. 登录 [api123.icu](https://api123.icu) → 控制台 → 令牌管理
2. 确认令牌有效并重新复制(无首尾空格)
3. 检查账号余额/套餐是否有效
---
## 五、配置文件内容
```json
{
"model": "claude-sonnet-4-5-20250929",
"env": {
"ANTHROPIC_API_KEY": "sk-h7VW10iTSSXo6xJXe44nI1vUhsEcG3H8Z9XyFmWABvhaD4ZW",
"ANTHROPIC_BASE_URL": "https://api123.icu",
"ANTHROPIC_MODEL": "claude-sonnet-4-5-20250929"
},
"anthropicBaseUrl": "https://api123.icu",
"anthropicApiKey": "sk-h7VW10iTSSXo6xJXe44nI1vUhsEcG3H8Z9XyFmWABvhaD4ZW",
"defaultModel": "claude-sonnet-4-5-20250929"
}
```
---
## 六、相关文档
- 完整配置说明:`运营中枢/参考资料/Claude_Code_api123配置说明.md`
- 修复脚本:`运营中枢/参考资料/scripts/fix_claude_503.sh`
- 一键设置脚本:`运营中枢/工作台/阿猫Mac_设置api123为默认API.sh`
---
*诊断完成时间2026-03-20*

View File

@@ -0,0 +1,283 @@
# Cursor 写入优化方案
> **分析时间**2026-03-20
> **问题**:每次写入 26 MB 太大,需要优化方案
---
## 一、为什么每次写入这么大?
### 1.1 根本原因
**Cursor 的代码跟踪机制**
- Cursor 不是按**文件级别**跟踪,而是按**代码片段级别**跟踪
- 每个代码片段(函数、类、代码块)都会生成一个独立的 hash
- 一个文件可能被拆分成**数百到数千个**代码片段
- 每个片段写入一行记录(~370 字节)
**实际案例**
- `index.tsx` 一个文件被写入 **33,019 次**33,019 个代码片段)
- 最大请求3,757 个文件 → 3,044,085 行(平均每个文件 810 个片段)
### 1.2 数据冗余分析
| 指标 | 数值 | 说明 |
|------|------|------|
| **hash 重复率** | **0%** | hash 是主键,不会重复(这是正常的) |
| **文件重复写入** | **严重** | 同一文件在不同请求中被重复写入 |
| **字段冗余** | **中等** | requestId、conversationId 等字段重复存储 |
**问题**
- ✅ hash 不重复(正常,用于去重)
- ❌ 同一文件被写入多次(不同请求时重复扫描)
- ❌ 每个代码片段都单独存储(而不是文件级别)
---
## 二、这个写入格式是否必要?
### 2.1 必要性的分析
**Cursor 使用这些数据做什么**
1. **代码变更检测**:通过 hash 判断代码是否被修改
2. **AI 评分**评估代码质量scored_commits 表)
3. **对话关联**:关联代码片段与对话会话
4. **模型追踪**:记录使用了哪个 AI 模型
**是否必要**
-**部分必要**代码变更检测、AI 评分确实需要
-**过度细化**:代码片段级别太细,文件级别可能就够了
-**重复写入**:同一文件在不同请求中重复扫描和写入
### 2.2 可以优化的地方
1. **降低粒度**:从代码片段级别 → 文件级别(减少 99% 的写入)
2. **去重优化**:同一文件在同一对话中只写入一次
3. **字段精简**:某些字段可以合并或简化
4. **定期清理**:清理旧数据,只保留最近 N 天的
---
## 三、处理方案
### 3.1 方案一:禁用代码跟踪(最彻底)
**方法**:在 Cursor 设置中禁用代码跟踪功能
**步骤**
1. 打开 Cursor SettingsCmd+,
2. 搜索 `tracking``code tracking`
3. 找到相关设置并禁用
**注意**:可能没有直接的设置项,需要查看 Cursor 官方文档或等待官方支持
**影响**
- ✅ 完全停止写入 ai-code-tracking.db
- ❌ 可能失去代码变更检测功能
- ❌ 可能影响 AI 评分功能
### 3.2 方案二:定期清理旧数据(推荐)
**方法**:定期清理超过 N 天的旧数据,只保留最近的数据
**脚本**:创建定期清理脚本
```bash
#!/usr/bin/env bash
# 清理 ai-code-tracking.db 中超过 30 天的旧数据
DB="$HOME/.cursor/ai-tracking/ai-code-tracking.db"
DAYS_TO_KEEP=30
# 计算保留时间戳30 天前)
CUTOFF_TS=$(date -v-${DAYS_TO_KEEP}d +%s)000
sqlite3 "$DB" "
DELETE FROM ai_code_hashes
WHERE createdAt < $CUTOFF_TS;
VACUUM;
"
```
**优点**
- ✅ 保留最近数据,不影响当前使用
- ✅ 自动释放空间
- ✅ 不影响 Cursor 功能
**缺点**
- ❌ 仍然会写入新数据(只是定期清理旧数据)
### 3.3 方案三:减少工作区数量
**方法**:减少 Cursor 同时打开的工作区数量
**当前状态**7 个工作区根目录
**建议**
- 只打开当前需要的工作区1-2 个)
- 关闭不需要的工作区
**效果**
- ✅ 减少扫描的文件数量
- ✅ 减少每次写入的行数
- ✅ 降低数据库增长速度
### 3.4 方案四:使用符号链接隔离大项目
**方法**:将大项目移到外置硬盘,用符号链接连接
**步骤**
1. 将大项目移到外置硬盘
2. 在原位置创建符号链接
3. Cursor 仍然可以访问,但数据写入到外置硬盘
**优点**
- ✅ 不占用主盘空间
- ✅ 不影响功能
### 3.5 方案五:等待 Cursor 官方优化
**方法**:向 Cursor 官方反馈问题,等待优化
**反馈渠道**
- Cursor Forum: https://forum.cursor.com
- GitHub Issues如果有开源部分
- 官方支持邮箱
**反馈内容**
- ai-code-tracking.db 增长过快
- 建议从代码片段级别改为文件级别跟踪
- 建议添加自动清理机制
---
## 四、推荐方案组合
### 4.1 立即执行(解决当前问题)
1. **定期清理脚本**(方案二)
- 每周清理一次超过 30 天的旧数据
- 预计释放:每月 ~500 MB - 1 GB
2. **减少工作区数量**(方案三)
- 只保留 1-2 个当前需要的工作区
- 预计减少:每次写入减少 50-70%
### 4.2 长期优化
1. **向 Cursor 官方反馈**(方案五)
- 建议优化跟踪粒度
- 建议添加自动清理机制
2. **监控数据库大小**
- 每周检查一次
- 超过 500 MB 时执行清理
---
## 五、优化脚本(已创建)
### 5.1 定期清理脚本
**脚本路径**`运营中枢/参考资料/scripts/cursor_clean_ai_tracking_old.sh`
**使用方法**
```bash
# Cmd+Q 退出 Cursor 后执行
bash "/Users/karuo/Documents/个人/卡若AI/运营中枢/参考资料/scripts/cursor_clean_ai_tracking_old.sh" [保留天数默认30]
```
**示例**
```bash
# 保留最近 30 天(默认)
bash cursor_clean_ai_tracking_old.sh
# 保留最近 7 天(更激进)
bash cursor_clean_ai_tracking_old.sh 7
# 保留最近 90 天(更保守)
bash cursor_clean_ai_tracking_old.sh 90
```
**脚本功能**
- 清理超过 N 天的旧数据(默认 30 天)
- 自动压缩数据库VACUUM
- 显示清理前后的对比数据
- 安全检查Cursor 运行时不允许执行)
**脚本已创建**`运营中枢/参考资料/scripts/cursor_clean_ai_tracking_old.sh`
```bash
#!/usr/bin/env bash
# 清理 ai-code-tracking.db 中超过 N 天的旧数据(保留最近数据)
DB="$HOME/.cursor/ai-tracking/ai-code-tracking.db"
DAYS_TO_KEEP=${1:-30} # 默认保留 30 天
if [ ! -f "$DB" ]; then
echo "❌ 未找到数据库:$DB"
exit 1
fi
# 检查 Cursor 是否在运行
if pgrep -f "Cursor" >/dev/null 2>&1; then
echo "⚠️ Cursor 正在运行,请先退出 Cursor 后执行"
exit 1
fi
BEFORE_SIZE=$(du -m "$DB" | awk '{print $1}')
CUTOFF_TS=$(python3 -c "import time; print(int((time.time() - $DAYS_TO_KEEP * 86400) * 1000))")
echo "🧹 清理超过 ${DAYS_TO_KEEP} 天的旧数据..."
sqlite3 "$DB" "
DELETE FROM ai_code_hashes
WHERE createdAt < $CUTOFF_TS;
VACUUM;
" 2>&1
AFTER_SIZE=$(du -m "$DB" | awk '{print $1}')
SAVED=$((BEFORE_SIZE - AFTER_SIZE))
echo "✅ 清理完成"
echo " 清理前: ${BEFORE_SIZE} MB"
echo " 清理后: ${AFTER_SIZE} MB"
echo " 释放: ${SAVED} MB"
```
### 5.2 自动清理(可选)
可以创建 LaunchAgent每周自动清理一次需要时再创建
---
## 六、总结
### 6.1 为什么这么大?
1. **代码片段级别跟踪**:每个代码片段一行记录
2. **文件被拆分**:一个文件可能被拆分成数百到数千个片段
3. **批量写入**:一次请求可能扫描数千个文件
4. **只增不删**:没有自动清理机制
### 6.2 是否必要?
- **部分必要**代码变更检测、AI 评分需要
- **过度细化**:代码片段级别太细,可以优化为文件级别
- **可以优化**:减少粒度、定期清理、减少工作区
### 6.3 处理方式
**立即执行**
1. 定期清理旧数据(保留 30 天)
2. 减少工作区数量(只保留 1-2 个)
**长期优化**
1. 向 Cursor 官方反馈
2. 监控数据库大小
3. 考虑迁移到外置硬盘
---
*报告生成时间2026-03-20*

View File

@@ -0,0 +1,271 @@
# Cursor 数据库写入分析报告
> **分析时间**2026-03-20
> **问题**Cursor 自动关闭,数据库文件过大(总计约 23GB
---
## 一、问题总览
| 数据库/目录 | 大小 | 行数/文件数 | 状态 |
|-----------|------|------------|------|
| **state.vscdb** | **11 GB** | 73.8 万行 | 🔴 严重膨胀 |
| **ai-code-tracking.db** | **1.0 GB** | 358 万行 | 🔴 严重膨胀 |
| **snapshots/** | **11 GB** | 未知 | 🔴 严重膨胀 |
| **总计** | **~23 GB** | — | 🔴 需要立即处理 |
---
## 二、ai-code-tracking.db 详细分析
### 2.1 数据库结构
```sql
CREATE TABLE ai_code_hashes (
hash TEXT PRIMARY KEY, -- 代码哈希(主键)
source TEXT NOT NULL, -- 源代码内容
fileExtension TEXT, -- 文件扩展名
fileName TEXT, -- 文件名
requestId TEXT, -- 请求ID
conversationId TEXT, -- 对话ID
timestamp INTEGER, -- 时间戳
model TEXT, -- 模型名称
createdAt INTEGER NOT NULL -- 创建时间
);
```
### 2.2 数据规模
| 指标 | 数值 |
|------|------|
| **总行数** | **3,585,067 行** |
| **文件大小** | **1.0 GB** |
| **平均每行大小** | **~280 字节**(含索引开销) |
| **最后修改时间** | 2026-03-20 04:51 |
### 2.3 写入内容
**每次写入的内容**
- **hash**:代码片段的哈希值(用于去重)
- **source**:完整的源代码内容(这是主要占用)
- **fileExtension / fileName**:文件信息
- **requestId / conversationId**:关联的请求和对话
- **timestamp / createdAt**:时间戳
- **model**:使用的 AI 模型
**写入触发时机**
1. **Agent 分析代码时**:每次 Agent 读取/分析文件,都会生成哈希并存储
2. **代码变更时**文件修改后Cursor 会重新计算哈希
3. **对话中引用代码时**:在对话中提到代码片段,会记录到数据库
### 2.4 增长模式
**实测数据**(基于 6 天数据):
- **时间范围**2026-03-13 至 2026-03-206 天)
- **总行数**3,585,067 行
- **平均每天增长****597,511 行**
- **每天增长大小****约 126 MB**
- **问题****只增不删**,没有过期清理机制
**增长原因**
- 每次 Agent 分析代码时,会为每个文件/代码片段生成哈希并存储
- 项目文件多、使用频繁 → 每天写入 60 万行
- 6 天就积累了 358 万行、1.0 GB
---
## 三、state.vscdb 详细分析
### 3.1 数据分布
| 数据类型 | 行数 | 占比 | 说明 |
|---------|------|------|------|
| **bubbleId**(对话气泡) | **706,381** | 95.7% | 所有聊天会话数据 |
| **agentKv:blob**Agent 缓存) | **3,367** | 0.5% | 代码分析缓存 |
| **其他中间数据** | **28,267** | 3.8% | checkpointId / codeBlockDiff 等 |
### 3.2 写入内容
**bubbleId对话气泡**
- 每个对话会话一个主 key`bubbleId:<会话UUID>`
- 子 key`bubbleId:<会话UUID>:<子项UUID>`(消息、状态等)
- **平均大小**:约 **13-15 KB/条**
- **总占用**:约 **9.6 GB**70.6 万行 × 13.5 KB
**agentKv:blobAgent 缓存)**
- Key 格式:`agentKv:blob:<64位十六进制>`
- Value二进制 blob代码/文件的哈希或嵌入向量)
- **平均大小**:约 **17 KB/条**
- **总占用**:约 **57 MB**3,367 行 × 17 KB
### 3.3 增长模式
- **每次对话**:创建 1 个主 bubbleId + 多个子 key每条消息、每个状态
- **每次 Agent 分析**:可能写入多个 agentKv:blob
- **每天增长**:取决于对话数量和 Agent 使用频率
- **问题****只增不删**,历史对话全部保留
---
## 四、snapshots 目录分析
### 4.1 目录大小
- **总大小****11 GB**
- **位置**`~/Library/Application Support/Cursor/snapshots/`
- **子目录**
- `codebases/`**10 GB**(代码库快照)
- `roots/`**1.1 GB**(工作区根目录快照)
### 4.2 用途
- **代码快照**:用于代码对比、历史版本查看
- **工作区快照**:保存工作区状态
- **问题**:同样只增不删,长期积累导致 11 GB
### 4.3 清理建议
- 可考虑清理旧快照(需确认 Cursor 是否依赖)
- 或迁移到外置硬盘
---
## 五、为什么这么大?
### 5.1 根本原因
1. **没有过期清理机制**
- Cursor 设计上保留所有历史数据
- 没有按时间/大小自动清理策略
2. **频繁写入且只增不删**
- 每次 Agent 分析 → 写入 ai_code_hashes
- 每次对话 → 写入 bubbleId
- 每次代码变更 → 重新计算哈希
3. **数据冗余**
- 同一代码片段可能被多次哈希存储
- 对话历史完整保留(包括已不需要的旧对话)
4. **数据库未压缩**
- SQLite 删除数据后不会自动回收空间
- 需要手动执行 VACUUM
### 5.2 写入频率估算
**ai-code-tracking.db**
- 每次 Agent 分析:写入 **10-100 行**(取决于文件数量)
- 每次代码变更:写入 **1-10 行**
- **实测:每天约 60 万行** → **约 126 MB/天**(非常快!)
**state.vscdb**
- 每次对话:写入 **1 个主 bubbleId + N 个子 key**N = 消息数)
- 每次 Agent 分析:可能写入 **1-10 个 agentKv:blob**
- **每天约 1-5 MB**(取决于对话频率)
---
## 六、解决方案
### 6.1 立即处理(推荐)
**方案一:智能瘦身(保留对话)**
```bash
# Cmd+Q 退出 Cursor 后执行
bash "/Users/karuo/Documents/个人/卡若AI/运营中枢/参考资料/scripts/cursor_slim_db.sh"
```
**效果**
- 清理 agentKv:blob可重建
- 清理 bubbleId对话会显示空白但 jsonl 原文保留)
- VACUUM 压缩数据库
- **预计释放:~20 GB**
**方案二:清理 ai-code-tracking.db**
```bash
# Cmd+Q 退出 Cursor 后执行
bash "/Users/karuo/Documents/个人/卡若AI/运营中枢/参考资料/scripts/cursor_clean_ai_tracking.sh"
```
**效果**
- 清空 ai_code_hashesCursor 会按需重建)
- 清理旧 scored_commits保留最近 1000 条)
- VACUUM 压缩
- **预计释放:~1 GB**
**方案三:深度修复(会丢失对话)**
```bash
# Cmd+Q 退出 Cursor 后执行
bash "/Users/karuo/Documents/个人/卡若AI/运营中枢/参考资料/scripts/cursor_deep_fix.sh"
```
**效果**
- 重置 state.vscdb会丢失所有对话
- 清理所有缓存
- **预计释放:~23 GB**
### 6.2 预防措施
**已启用**
- ✅ LaunchAgent 自动瘦身(每周一凌晨 4:00
- ✅ argv.json 已设 `--max-old-space-size=8192`(防止 V8 OOM
**建议**
1. **定期手动瘦身**:每月执行一次 `cursor_slim_db.sh`
2. **减少同窗口工作区**:当前 7 个,建议控制在 3 个以内
3. **关闭不需要的对话**:及时关闭不再使用的 Agent 对话
4. **监控数据库大小**:定期检查 state.vscdb 和 ai-code-tracking.db 大小
### 6.3 长期方案
1. **迁移到外置硬盘**(不删数据)
```bash
bash ".../cursor_move_global_storage.sh" /Volumes/外置硬盘/CursorData
```
2. **等待 Cursor 官方修复**:向官方反馈数据库膨胀问题
---
## 七、执行建议
### 立即执行(解决自动关闭)
1. **Cmd+Q 完全退出 Cursor**
2. **执行智能瘦身**
```bash
bash "/Users/karuo/Documents/个人/卡若AI/运营中枢/参考资料/scripts/cursor_slim_db.sh"
```
3. **执行 ai-tracking 清理**
```bash
bash "/Users/karuo/Documents/个人/卡若AI/运营中枢/参考资料/scripts/cursor_clean_ai_tracking.sh"
```
4. **重新打开 Cursor**
**预计总释放**~21 GBstate.vscdb 从 11GB → ~50MBai-code-tracking.db 从 1GB → ~10MB
### 后续维护
- **每周检查**`du -sh ~/Library/Application\ Support/Cursor/User/globalStorage/state.vscdb`
- **每月瘦身**:执行 `cursor_slim_db.sh`
- **snapshots 目录**:待进一步分析后决定是否清理
---
## 八、数据保留说明
| 数据 | 清理后状态 | 恢复方式 |
|------|-----------|---------|
| **对话气泡bubbleId** | UI 显示空白 | 对话原文在 `~/.cursor/projects/*/agent-transcripts/*.jsonl` |
| **Agent 缓存agentKv:blob** | 清空 | Cursor 按需自动重建 |
| **ai_code_hashes** | 清空 | Cursor 按需自动重建 |
| **编辑器状态ItemTable** | 保留 | 不受影响 |
**重要**:所有对话的完整 jsonl 文件都会保留,只是 Cursor UI 中不显示历史对话。
---
*报告生成时间2026-03-20*

View File

@@ -0,0 +1,260 @@
# Cursor 24GB 问题根本性解决方案
> **问题**Cursor 数据库已膨胀到 24GB导致自动关闭
> **目标**:一次性解决,并建立长期预防机制
> **日期**2026-03-20
---
## 一、当前问题诊断
### 1.1 实际大小分布
| 文件/目录 | 大小 | 占比 | 可清理 |
|-----------|------|------|--------|
| **state.vscdb** | **11 GB** | 46% | ✅ 可清空 cursorDiskKV |
| **snapshots/** | **11 GB** | 46% | ✅ 可删除(代码快照) |
| **ai-code-tracking.db** | **1.0 GB** | 4% | ✅ 可清空 |
| **Partitions/** | 1.4 GB | 6% | ⚠️ 部分可清理 |
| **logs/** | 236 MB | 1% | ✅ 可清理旧日志 |
| **其他** | ~200 MB | 1% | ✅ 可清理缓存 |
| **总计** | **~24 GB** | 100% | |
### 1.2 最大占用分析
**snapshots/codebases/** 中最大的几个:
- `7072d90f-...`: **8.4 GB**(单个代码库快照)
- `53ff244c-...`: **805 MB**
- `869d1dfb-...`: **418 MB**
**问题根源**
1. **代码快照无限增长**:每个工作区的代码快照都完整保存
2. **对话数据只增不删**70 万行对话气泡数据
3. **代码跟踪过度细化**:代码片段级别跟踪,每天写入 60 万行
---
## 二、根本性解决方案
### 方案一:激进清理(推荐,立即执行)✅
**脚本**`cursor_radical_clean.sh`(已创建)
**清理内容**
1. ✅ 清空 `ai-code-tracking.db`Cursor 会按需重建)
2. ✅ 清空 `state.vscdb``cursorDiskKV`(对话显示空白,但 jsonl 原文保留)
3. ✅ 删除 `snapshots/` 目录(代码快照,可重建)
4. ✅ 清理所有缓存和临时文件
**预计释放****20-22 GB**
**执行步骤**
```bash
# 1. Cmd+Q 完全退出 Cursor
# 2. 执行清理脚本
bash "/Users/karuo/Documents/个人/卡若AI/运营中枢/参考资料/scripts/cursor_radical_clean.sh"
# 3. 重新打开 Cursor首次启动会稍慢 10-20 秒)
```
**注意事项**
- ✅ 对话原文在 `~/.cursor/projects/*/agent-transcripts/*.jsonl`(不会删除)
- ✅ Cursor 重启后会重建必要的数据库
- ⚠️ 旧对话在 Cursor UI 中显示空白(但 jsonl 原文仍在)
### 方案二:定期自动清理(长期预防)
**脚本**`cursor_clean_ai_tracking_old.sh`(已创建)
**策略**
- **每周执行一次**,保留最近 7 天数据
- 或**每月执行一次**,保留最近 30 天数据
**自动执行**(可选):
创建 LaunchAgent每周一凌晨 4:00 自动执行
### 方案三:减少工作区数量
**当前状态**7 个工作区根目录
**建议**
- 只保留 1-2 个当前需要的工作区
- 关闭不需要的工作区
**效果**
- ✅ 减少扫描的文件数量
- ✅ 减少每次写入的行数(预计减少 50-70%
- ✅ 减少 snapshots 占用
### 方案四:迁移到外置硬盘(不删数据)
**方法**:将整个 `globalStorage` 迁移到外置硬盘
**脚本**`cursor_move_global_storage.sh`(已有)
**优点**
- ✅ 不删除数据
- ✅ 不占用主盘空间
- ✅ 不影响功能
**缺点**
- ⚠️ 需要外置硬盘
- ⚠️ 数据仍在增长(只是换位置)
---
## 三、立即执行步骤
### 3.1 激进清理(解决 24GB 问题)
```bash
# 1. 完全退出 CursorCmd+Q
# 2. 执行激进清理
bash "/Users/karuo/Documents/个人/卡若AI/运营中枢/参考资料/scripts/cursor_radical_clean.sh"
# 3. 等待清理完成(可能需要 1-2 分钟)
# 4. 重新打开 Cursor
```
**预期结果**
- 清理前:~24 GB
- 清理后:~2-3 GB
- 释放:~20-22 GB
### 3.2 建立长期预防机制
**每周执行一次**(保留 7 天):
```bash
# Cmd+Q 退出 Cursor 后执行
bash "/Users/karuo/Documents/个人/卡若AI/运营中枢/参考资料/scripts/cursor_clean_ai_tracking_old.sh" 7
```
**或每月执行一次**(保留 30 天):
```bash
bash "/Users/karuo/Documents/个人/卡若AI/运营中枢/参考资料/scripts/cursor_clean_ai_tracking_old.sh" 30
```
---
## 四、预防措施
### 4.1 减少工作区数量
**当前**7 个工作区根目录
**建议**:只保留 1-2 个当前需要的工作区
**操作**
1. 关闭不需要的工作区File → Close Folder
2. 只打开当前正在使用的项目
### 4.2 定期监控
**每周检查一次**
```bash
du -sh ~/Library/Application\ Support/Cursor/User/globalStorage/state.vscdb
du -sh ~/.cursor/ai-tracking/ai-code-tracking.db
du -sh ~/Library/Application\ Support/Cursor/snapshots
```
**超过阈值时清理**
- `state.vscdb` > 2 GB → 执行 `cursor_slim_db.sh`
- `ai-code-tracking.db` > 500 MB → 执行 `cursor_clean_ai_tracking_old.sh 7`
- `snapshots/` > 5 GB → 执行 `cursor_radical_clean.sh`(只清理 snapshots
### 4.3 向 Cursor 官方反馈
**反馈内容**
1. 数据库增长过快24GB
2. 建议优化跟踪粒度(代码片段 → 文件级别)
3. 建议添加自动清理机制
4. 建议添加配置选项(禁用代码跟踪)
**反馈渠道**
- Cursor Forum: https://forum.cursor.com
- 官方支持邮箱
---
## 五、脚本清单
| 脚本 | 用途 | 预计释放 |
|------|------|----------|
| **cursor_radical_clean.sh** | 激进清理(一次性解决 24GB | **20-22 GB** |
| cursor_clean_ai_tracking_old.sh | 定期清理旧数据(保留 N 天) | 500 MB - 1 GB/次 |
| cursor_slim_db.sh | 智能瘦身 state.vscdb | 10-11 GB |
| cursor_move_global_storage.sh | 迁移到外置硬盘 | 0换位置 |
---
## 六、执行建议
### 立即执行(解决 24GB
1. **Cmd+Q 完全退出 Cursor**
2. **执行激进清理**
```bash
bash "/Users/karuo/Documents/个人/卡若AI/运营中枢/参考资料/scripts/cursor_radical_clean.sh"
```
3. **重新打开 Cursor**
### 长期预防
1. **每周执行一次清理**(保留 7 天)
2. **减少工作区数量**(只保留 1-2 个)
3. **定期监控数据库大小**
4. **向 Cursor 官方反馈**
---
## 七、常见问题
### Q1: 清理后对话会丢失吗?
**A**: 不会。对话原文保存在 `~/.cursor/projects/*/agent-transcripts/*.jsonl`,不会被删除。只是 Cursor UI 中显示空白,但原文仍在。
### Q2: 清理后 Cursor 功能会受影响吗?
**A**: 不会。Cursor 会按需重建必要的数据库。首次启动会稍慢10-20 秒),之后正常。
### Q3: 为什么不能禁用代码跟踪?
**A**: Cursor 目前没有提供禁用选项。只能通过定期清理来缓解。建议向官方反馈。
### Q4: 清理后多久会再次达到 24GB
**A**: 取决于使用频率:
- **轻度使用**(每天 1-2 次分析):约 3-6 个月
- **中度使用**(每天 5-10 次分析):约 1-2 个月
- **重度使用**(每天 10+ 次分析):约 2-4 周
**建议**:每周执行一次清理(保留 7 天),可长期保持在 2-5 GB。
---
## 八、总结
### 8.1 根本原因
1. **代码快照无限增长**snapshots/ 目录 11 GB
2. **对话数据只增不删**state.vscdb 11 GB
3. **代码跟踪过度细化**ai-code-tracking.db 每天写入 60 万行
### 8.2 解决方案
**立即执行**
- ✅ 激进清理脚本(一次性释放 20-22 GB
**长期预防**
- ✅ 每周清理旧数据(保留 7 天)
- ✅ 减少工作区数量(只保留 1-2 个)
- ✅ 定期监控数据库大小
### 8.3 预期效果
- **清理后**:从 24 GB → 2-3 GB
- **长期维护**:保持在 2-5 GB每周清理
- **不再自动关闭**:数据库大小恢复正常
---
*报告生成时间2026-03-20*

View File

@@ -0,0 +1,261 @@
# Cursor 每次写入详细分析报告
> **分析时间**2026-03-20
> **目的**:了解每次写入的数据量、写入机制、写入内容
---
## 一、ai-code-tracking.db 写入分析
### 1.1 每次写入的数据量
**单次请求写入统计**(基于 50 个请求样本):
| 指标 | 数值 |
|------|------|
| **平均每次请求写入行数** | **70,813 行** |
| **平均每次请求写入大小** | **553 KB**(仅 source 字段,不含其他字段) |
| **平均每行实际大小** | **~370 字节**(所有字段 + 数据库开销) |
| **字段大小明细** | hash(8) + source(8) + fileExtension(3) + fileName(44) + requestId(36) + conversationId(36) + model(1) + 时间戳(16) + 开销(200) ≈ 370 字节 |
**写入范围**
- **最小请求**609 行,约 4.76 KB
- **最大请求**3,044,085 行,约 23.8 MB一次性写入
- **典型请求**1,000-5,000 行,约 8-40 KB
### 1.2 写入机制
**触发时机**
1. **Agent 分析代码时**Cursor Agent 分析项目文件时,会批量写入
2. **代码变更时**文件修改后Cursor 重新计算哈希
3. **对话中引用代码时**:在对话中提到代码片段
**写入模式**
- **批量写入**每次请求会一次性写入多个文件10-300 万行)
- **事务性**:同一 `requestId` 的所有写入在同一事务中完成
- **去重机制**:通过 `hash` 主键去重,相同代码不会重复写入
**典型写入流程**
```
Agent 分析请求开始
生成 requestId如 toolu_vrtx_01GWFNvmCNcoLhC42Bd6duvE
扫描项目文件(可能数千个文件)
为每个文件/代码片段生成 hash
批量写入数据库(一次事务写入数万行)
写入完成
```
### 1.3 写入内容详解
**表结构**
```sql
CREATE TABLE ai_code_hashes (
hash TEXT PRIMARY KEY, -- 代码哈希(主键,约 8 字节)
source TEXT NOT NULL, -- 源代码标识(约 8 字节,如 "composer"
fileExtension TEXT, -- 文件扩展名(如 "py", "md", "tsx"
fileName TEXT, -- 完整文件路径(平均 44 字节)
requestId TEXT, -- 请求IDUUID36 字节)
conversationId TEXT, -- 对话IDUUID36 字节)
timestamp INTEGER, -- 时间戳8 字节)
model TEXT, -- 模型名称(如 "claude-4.6-sonnet-medium-thinking"
createdAt INTEGER NOT NULL -- 创建时间戳8 字节)
);
```
**字段内容**
- **hash**8 位十六进制字符串(如 `2d377592`),用于唯一标识代码片段
- **source**:标识来源,值为 `"composer"``"human"`8 字节)
- `"composer"`:通过 Cursor Composer 生成的代码
- `"human"`:人工编写的代码
- **fileExtension**:文件扩展名(如 `py`, `md`, `tsx`, `json`
- **fileName**:完整文件路径(平均 44 字节)
- **requestId**UUID 格式36 字节),标识单次 Agent 分析请求
- **conversationId**UUID 格式36 字节),关联的对话会话
- **model**AI 模型名称(如 `claude-4.6-sonnet-medium-thinking`
**文件类型分布**(前 15 种):
| 扩展名 | 行数 | 占比 |
|--------|------|------|
| txt | 2,853,842 | 79.6% |
| md | 160,116 | 4.5% |
| py | 123,383 | 3.4% |
| tsx | 114,692 | 3.2% |
| php | 52,380 | 1.5% |
| csv | 51,939 | 1.4% |
| 其他 | 229,515 | 6.4% |
### 1.4 为什么这么大?
**数据量计算**
- 总行数3,585,067 行
- 平均每行:~280 字节(字段 + 数据库开销)
- **理论大小**3,585,067 × 280 字节 ≈ **958 MB**
- **实际文件大小**1.0 GB
- **差异**:约 42 MB索引、WAL 日志等)
**增长速度快的原因**
1. **批量写入**:每次 Agent 分析可能写入数万行
2. **只增不删**:没有过期清理机制
3. **频繁触发**:每次代码变更、每次 Agent 分析都会写入
4. **项目文件多**:项目越大,每次写入越多
---
## 二、state.vscdb 写入分析
### 2.1 每次写入的数据量
**bubbleId对话气泡**
- **平均大小**:约 **13-15 KB/条**
- **大小范围**:几 KB 到几十 KB
- **写入时机**:每次创建新对话、每次发送消息、每次状态变更
**agentKv:blobAgent 缓存)**
- **平均大小**:约 **1.5 KB/条**
- **大小范围**0.02 KB - 14.63 KB
- **写入时机**:每次 Agent 分析代码时
### 2.2 写入机制
**bubbleId 写入流程**
```
创建新对话
生成 bubbleIdUUID
写入主记录bubbleId:<UUID>(包含对话元数据)
每次发送消息
写入子记录bubbleId:<UUID>:<子项UUID>(消息内容)
每次状态变更
更新或新增子记录
```
**agentKv:blob 写入流程**
```
Agent 分析代码
计算代码/文件的哈希64 位十六进制)
生成嵌入向量或缓存数据
写入agentKv:blob:<hash>(二进制 blob
```
### 2.3 写入内容详解
**bubbleId 内容结构**JSON 格式):
```json
{
"title": "对话标题",
"messages": [
{
"role": "user",
"content": "用户消息内容"
},
{
"role": "assistant",
"content": "AI 回复内容"
}
],
"metadata": {
"createdAt": 时间戳,
"updatedAt": 时间戳,
...
}
}
```
**agentKv:blob 内容**
- **Key 格式**`agentKv:blob:<64位十六进制hash>`
- **Value**:二进制 blob代码嵌入向量、分析结果等
- **用途**:用于快速判断代码是否变更、是否需要重新分析
### 2.4 数据分布
| 数据类型 | 行数 | 平均大小 | 总占用 |
|---------|------|----------|--------|
| **bubbleId** | 706,381 | 13-15 KB | ~9.6 GB |
| **bubbleId** | 未知 | 几 KB | 包含在 9.6 GB 中 |
| **agentKv:blob** | 3,367 | 1.5 KB | ~57 MB |
| **其他** | 28,267 | 变化 | ~1.3 GB |
---
## 三、写入频率估算
### 3.1 ai-code-tracking.db
**基于实测数据**6 天358 万行):
- **每天写入**:约 **60 万行**
- **每天增长**:约 **126 MB**
- **每次请求平均**70,813 行553 KB
- **每天请求次数估算**60 万 ÷ 70,813 ≈ **8-9 次** Agent 分析
**典型场景**
- **轻度使用**(每天 1-2 次分析):每天写入 7-14 万行,约 20-40 MB
- **中度使用**(每天 5-10 次分析):每天写入 35-70 万行,约 100-200 MB
- **重度使用**(每天 10+ 次分析):每天写入 70 万+ 行200+ MB
### 3.2 state.vscdb
**bubbleId**
- **每次新对话**:写入 1 个主记录13-15 KB
- **每次消息**:写入 1 个子记录(几 KB
- **每天估算**:取决于对话数量和消息数
**agentKv:blob**
- **每次 Agent 分析**:可能写入 1-10 个 blob每个 1.5 KB
- **每天估算**:取决于 Agent 使用频率
---
## 四、总结
### 4.1 每次写入大小
| 数据库 | 写入类型 | 平均大小 | 范围 |
|--------|---------|----------|------|
| **ai-code-tracking.db** | 单次请求 | **553 KB** | 4.76 KB - 23.8 MB |
| **state.vscdb** | bubbleId | **13-15 KB** | 几 KB - 几十 KB |
| **state.vscdb** | agentKv:blob | **1.5 KB** | 0.02 KB - 14.63 KB |
### 4.2 写入内容
**ai-code-tracking.db**
- 代码哈希hash
- 源代码标识source = "composer"
- 文件信息fileName, fileExtension
- 关联信息requestId, conversationId, model
- 时间戳
**state.vscdb**
- **bubbleId**对话消息、状态、元数据JSON 格式)
- **agentKv:blob**:代码分析缓存(二进制 blob
### 4.3 写入机制
- **批量写入**ai-code-tracking.db 每次请求批量写入数万行
- **事务性**:同一请求的所有写入在同一事务中
- **去重**:通过 hash 主键避免重复
- **只增不删**:没有自动清理机制,导致持续增长
### 4.4 为什么这么大?
1. **频繁写入**:每次 Agent 分析、每次对话都会写入
2. **批量写入**:单次请求可能写入数万行
3. **只增不删**:历史数据全部保留
4. **项目规模**:项目文件越多,每次写入越多
5. **数据库开销**索引、WAL 日志等额外占用
---
*报告生成时间2026-03-20*

View File

@@ -0,0 +1,84 @@
# Cursor 部分 Agent 对话「Internal Error」分析与处理
> 现象:同一台电脑上,**当前这个对话能连上**,但像「阿猫的苹果笔记本」等**部分 Agent 对话**点进去就报 **Internal Error**An unexpected error occurred on our servers...Request ID 示例:`dfd66dc1-1a0a-4278-a272-7cc4aab7a8c6`。
> 分析时间2026-03-19
---
## 一、原因结论(不是网络)
| 判断 | 说明 |
|------|------|
| **不是本机网络** | 同一台电脑、同一时刻,当前对话正常,说明网络和 Cursor 登录都正常。 |
| **是 Cursor 服务端报错** | 提示明确写的是 "**on our servers**",即请求在 Cursor 后端处理时出错。 |
| **和具体哪个 Agent/哪次对话有关** | 出错的只是某几个 Agent如「阿猫的苹果笔记本」且常伴随「刚改过很多文件」如 8 Files 等),说明是**该会话的上下文或状态**在服务端触发了异常。 |
可能触发服务端错误的原因(任一种或叠加):
1. **该对话上下文过大或异常**:历史太长、附带 8+ 文件变更、或含有特殊字符/结构,服务端处理时崩了。
2. **该 Agent 的会话状态损坏**:本机 `state.vscdb` 里该 Agent/会话的缓存(如 agentKv:blob异常同步到服务端时触发 bug。
3. **Cursor 已知 bug**:本机已有记录的 `AgentAnalyticsOperationsMainService` SQLite 嵌套事务等,和 Agent 频繁读写有关,可能加剧某些会话加载失败。
---
## 二、推荐处理顺序(同机可操作)
### 第 1 步先点「Try again」
- 在报错界面点 **Try again**,有时是临时抖动,重试一次即可恢复。
- 若连续 23 次仍报 Internal Error进入第 2 步。
### 第 2 步:用新对话接续,不依赖坏会话
- **不要死磕那个报错的 Agent 对话**。
- 新建一个 **Agent****新对话**把该任务的关键信息需求、api123 配置等)简短贴过去,在新对话里继续。
- 旧对话仅作备份即可,不必再打开,避免反复触发服务端错误。
### 第 3 步:可选——轻量清理 Cursor 缓存(缓解本地状态异常)
- 若希望减少「其他 Agent 也陆续连不上」的概率,可做一次**轻量清理**(不删聊天历史):
**完全退出 CursorCmd+Q** 后,在终端执行:
```bash
bash "/Users/karuo/Documents/个人/卡若AI/运营中枢/参考资料/scripts/clear_cursor_cache.sh"
```
- 该脚本只删 `GPUCache`、`Cache`、`CachedData`**不删** `state.vscdb`,不会清空 Agent 对话历史;重新打开 Cursor 后,有问题的会话仍可能报错,但新对话和其余 Agent 一般会更稳。
### 第 4 步:若仍大面积出现 Internal Error
- 考虑在 **Cursor 完全退出后** 跑一次 **Agent 缓存瘦身**(会删 agentKv:blob**对话历史保留**Cursor 会按需重建索引):
用 **`cursor_slim_db.sh`** 或 **`cursor_auto_slim.sh`**见《Cursor闪退排查_20260304》**不要用** `cursor_deep_fix.sh`(深度修复会移走整库,**会清掉所有 Agent 和所有聊天记录**)。
- 仍无效则可保留 Request ID向 Cursor 官方/Forum 反馈。
---
## 三、小结
| 项目 | 结论 |
|------|------|
| **原因** | **Agent/会话级** + **Cursor 服务端** 处理该会话时出错,不是网络也不是整机 Cursor 挂掉。 |
| **立刻可做** | Try again → 仍失败则用**新 Agent/新对话**接续,不反复打开报错会话。 |
| **可选** | 退出 Cursor 后执行 `clear_cursor_cache.sh`,必要时再按文档做 agent 缓存瘦身。 |
---
## 四、Agent 列表一直 Loading / 点不了(数据文件被删或清空后)
**现象**:右侧 Agent 列表一直显示加载中,或能看见列表但点击无反应、中间显示 "Loading Chat"。
**常见原因**`state.vscdb` 被删、被清空(如跑过瘦身脚本清空了 cursorDiskKV、或 composerData/bubbleId 损坏,导致 Cursor 无法加载对话内容。
**恢复步骤**(依赖 MongoDB 已归档的对话记录):
1. **完全退出 Cursor**Cmd+Q
2. 在终端执行(从 MongoDB 写回 state.vscdb
```bash
cd "/Users/karuo/Documents/个人/卡若AI/01_卡资/金仓_存储备份/聊天记录管理/脚本"
python3 agent_sync_restore.py restore --limit 80
```
3. **重新打开 Cursor**,右侧 Agent 列表应可正常点击,对话可打开。
若需恢复更多条,可把 `--limit 80` 改为 `200` 或去掉 `--limit`(默认 200。详见 `agent_sync_restore.py` 与聊天记录管理 SKILL。
---
*相关文档《Cursor闪退排查_20260304》《clear_cursor_cache.sh》、聊天记录管理 SKILL*

View File

@@ -396,3 +396,4 @@
| 2026-03-18 16:29:27 | 🔄 卡若AI 同步 2026-03-18 16:29 | 更新:卡木、卡土、运营中枢工作台 | 排除 >20MB: 11 个 |
| 2026-03-19 13:29:07 | 🔄 卡若AI 同步 2026-03-19 13:29 | 更新Cursor规则、金仓、卡人、水桥平台对接、火炬、总索引与入口、运营中枢参考资料、运营中枢工作台 | 排除 >20MB: 11 个 |
| 2026-03-19 13:29:38 | 🔄 卡若AI 同步 2026-03-19 13:29 | 更新:水桥平台对接、运营中枢参考资料、运营中枢工作台 | 排除 >20MB: 11 个 |
| 2026-03-19 13:43:52 | 🔄 卡若AI 同步 2026-03-19 13:43 | 更新:金仓、水桥平台对接、运营中枢工作台 | 排除 >20MB: 11 个 |

View File

@@ -399,3 +399,4 @@
| 2026-03-18 16:29:27 | 成功 | 成功 | 🔄 卡若AI 同步 2026-03-18 16:29 | 更新:卡木、卡土、运营中枢工作台 | 排除 >20MB: 11 个 | [仓库](http://open.quwanzhi.com:3000/fnvtk/karuo-ai) [百科](http://open.quwanzhi.com:3000/fnvtk/karuo-ai/wiki) |
| 2026-03-19 13:29:07 | 成功 | 成功 | 🔄 卡若AI 同步 2026-03-19 13:29 | 更新Cursor规则、金仓、卡人、水桥平台对接、火炬、总索引与入口、运营中枢参考资料、运营中枢工作台 | 排除 >20MB: 11 个 | [仓库](http://open.quwanzhi.com:3000/fnvtk/karuo-ai) [百科](http://open.quwanzhi.com:3000/fnvtk/karuo-ai/wiki) |
| 2026-03-19 13:29:38 | 成功 | 成功 | 🔄 卡若AI 同步 2026-03-19 13:29 | 更新:水桥平台对接、运营中枢参考资料、运营中枢工作台 | 排除 >20MB: 11 个 | [仓库](http://open.quwanzhi.com:3000/fnvtk/karuo-ai) [百科](http://open.quwanzhi.com:3000/fnvtk/karuo-ai/wiki) |
| 2026-03-19 13:43:52 | 成功 | 成功 | 🔄 卡若AI 同步 2026-03-19 13:43 | 更新:金仓、水桥平台对接、运营中枢工作台 | 排除 >20MB: 11 个 | [仓库](http://open.quwanzhi.com:3000/fnvtk/karuo-ai) [百科](http://open.quwanzhi.com:3000/fnvtk/karuo-ai/wiki) |

View File

@@ -0,0 +1,21 @@
# WebPomodoro 功能与静默命令对照表
> 不打开 WebPomodoro 界面,用卡罗帮静默脚本实现专注/番茄钟。卡若AI 执行「开始专注」「静默番茄钟」时用本表命令。
---
## 静默命令(一律不打开 APP
| 需求 | 静默命令 / 方式 |
|----------------|------------------|
| 开始专注 25 分钟(默认) | `python3 运营中枢/工作台/卡罗帮/scripts/pomodoro_silent.py --minutes 25 --notify` |
| 专注 N 分钟 | `python3 .../pomodoro_silent.py -m N --notify` |
| 静默专注且不弹通知 | `python3 .../pomodoro_silent.py -m 25 --no-notify` |
| 短休息 5 分钟 | `python3 .../pomodoro_silent.py --rest-short` |
| 长休息 15 分钟 | `python3 .../pomodoro_silent.py --rest-long` |
| 后台运行(不占前台) | `nohup python3 .../pomodoro_silent.py -m 25 --notify &``python3 .../pomodoro_silent.py -m 25 &` |
**脚本路径卡若AI 工作区根为项目根)**
`运营中枢/工作台/卡罗帮/scripts/pomodoro_silent.py`
**禁止**:为实现「开始专注」而执行 `open -a WebPomodoro``open /Applications/WebPomodoro.app`(会打开图形界面,非静默)。

View File

@@ -0,0 +1,79 @@
# WebPomodoro专注轻探静默控制方案卡罗帮 idea
> **目标**:不打开 WebPomodoro 图形界面,用命令行/脚本完成「开始专注 / 番茄钟计时 / 到时提醒」供卡若AI 与自动化流程静默调用。
> 维护:金仓;归属:卡罗帮(运营中枢/工作台/卡罗帮)。
---
## 一、WebPomodoro 官方 CLI 能力分析
### 1.1 应用信息macOS
- **路径**`/Applications/WebPomodoro.app`
- **Bundle ID**`com.macpomodoro`
- **类型**:原生 Cocoa 应用NSMainStoryboardFile、NSPrincipalClass=NSApplication非 Electron。
- **Info.plist**:未发现 `CFBundleURLTypes`,即**未注册 URL Scheme**(无 `webpomodoro://` 等)。
### 1.2 官方是否提供「不打开界面」的 CLI
- 应用为纯 GUI 形态,**未提供**独立命令行工具或「无头」模式。
- **结论**:官方没有「不启动 GUI、纯命令行」的静默接口若用 `open -a WebPomodoro` 或 AppleScript 控制,都会带出窗口,**无法做到完全静默、不打开界面**。
### 1.3 若必须用 WebPomodoro 本身
- **AppleScript / JXA**:可控制已运行的 WebPomodoro菜单、按钮但需先启动 APP会带出界面**不是静默操作**。
- **URL Scheme**:当前 plist 无 `CFBundleURLTypes`,无法通过 `open "webpomodoro://..."` 静默驱动。
---
## 二、静默控制思路(不打开 APP
核心思路:**用本方案提供的静默脚本实现「番茄钟 / 专注计时」**,不启动 WebPomodoro.app需要「计时 + 到时提醒」时,直接调用脚本即可。
| WebPomodoro 功能 | 静默实现方式 |
|------------------|--------------|
| 开始专注(如 25 分钟) | 调用 `scripts/pomodoro_silent.py --minutes 25`(或 `--focus 25` |
| 自定义时长 | `pomodoro_silent.py --minutes N` |
| 到时提醒 | 脚本内部用 macOS 通知(`osascript`)或仅写日志,不弹 APP 窗口 |
| 短休息 / 长休息 | `pomodoro_silent.py --rest-short` / `--rest-long`(可选,由脚本参数约定) |
**与 Navicat 方案一致**:不打开原 APP用「等价能力」的脚本/CLI 完成目标,实现**真正的静默操作**。
---
## 三、卡罗帮实现要点
### 3.1 静默脚本与对照表(已提供)
- **脚本**`运营中枢/工作台/卡罗帮/scripts/pomodoro_silent.py`
- **静默命令速查**:同目录 `WebPomodoro_功能与静默命令对照表.md`
- **行为**
- 不启动 WebPomodoro.app不打开任何图形界面。
- 支持 `--minutes N`(专注时长,默认 25`--notify`(结束时发 macOS 通知)、`--no-notify`(仅日志)。
- 可后台运行(如 `nohup ... &` 或由卡若AI/自动化调用),全程静默。
### 3.2 使用方式卡若AI
- 用户说「开始专注」「静默专注 25 分钟」「不打开界面开一个番茄钟」等:
直接执行:`python3 运营中枢/工作台/卡罗帮/scripts/pomodoro_silent.py --minutes 25 --notify`(或等价路径),**不**执行 `open -a WebPomodoro`
- 用户说「打开 WebPomodoro」「打开专注轻探」
若确需图形界面,再使用 `open -a WebPomodoro`;否则优先用静默脚本。
### 3.3 与 Skill / CLA 的衔接
- 若已有「专注轻探」或「WebPomodoro」的 Skill/CLA在 Skill 中明确写「静默操作用 `pomodoro_silent.py`,禁止为执行计时而打开 WebPomodoro 界面」。
- 触发词示例:**专注、番茄钟、静默专注、开始专注、不打开界面计时** → 调用静默脚本,不打开 APP。
---
## 四、无法静默替代的部分
- **WebPomodoro 独有功能**:如应用内的统计、主题、多设备同步等,无官方 API/CLI 时无法在不打开 APP 的前提下实现;本方案仅覆盖「计时 + 到时提醒」的静默等价。
---
## 五、版本记录
| 日期 | 变更 |
|------------|------|
| 2026-03-19 | 初版WebPomodoro CLI 分析、静默思路、静默脚本说明与卡若AI 使用方式。 |

View File

@@ -0,0 +1,111 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
静默番茄钟:不打开 WebPomodoro 界面,纯命令行计时 + 可选到时通知。
供卡若AI / 自动化流程调用,实现「开始专注 N 分钟」的静默操作。
归属:卡罗帮 · WebPomodoro 静默控制。
"""
import argparse
import subprocess
import sys
import time
from pathlib import Path
DEFAULT_MINUTES = 25
SCRIPT_DIR = Path(__file__).resolve().parent
LOG_DIR = SCRIPT_DIR.parent / "logs"
def notify_macos(title: str, body: str) -> None:
"""发送 macOS 原生通知(不打开任何 APP 窗口)。"""
try:
subprocess.run(
[
"osascript",
"-e",
f'display notification "{body}" with title "{title}" sound name "default"',
],
check=True,
capture_output=True,
)
except Exception as e:
print(f"[静默番茄钟] 通知发送失败: {e}", file=sys.stderr)
def main() -> int:
parser = argparse.ArgumentParser(
description="静默番茄钟:不打开 WebPomodoro命令行计时 + 可选到时通知"
)
parser.add_argument(
"--minutes", "-m",
type=int,
default=DEFAULT_MINUTES,
help=f"专注时长(分钟),默认 {DEFAULT_MINUTES}",
)
parser.add_argument(
"--notify",
action="store_true",
default=True,
help="结束时发送 macOS 通知(默认开启)",
)
parser.add_argument(
"--no-notify",
action="store_true",
help="不发送通知,仅打印日志",
)
parser.add_argument(
"--rest-short",
action="store_true",
help="短休息5 分钟)",
)
parser.add_argument(
"--rest-long",
action="store_true",
help="长休息15 分钟)",
)
parser.add_argument(
"--label", "-l",
type=str,
default="",
help="本次专注标签(会显示在通知中)",
)
args = parser.parse_args()
do_notify = args.notify and not args.no_notify
minutes = args.minutes
if args.rest_short:
minutes = 5
label = "短休息"
elif args.rest_long:
minutes = 15
label = "长休息"
else:
label = args.label or "专注"
seconds = minutes * 60
LOG_DIR.mkdir(parents=True, exist_ok=True)
log_file = LOG_DIR / "pomodoro_silent.log"
with open(log_file, "a", encoding="utf-8") as f:
f.write(f"[开始] {label} {minutes} 分钟\n")
print(f"[静默番茄钟] 开始 {label}{minutes} 分钟,不打开任何界面。", flush=True)
if do_notify:
print("[静默番茄钟] 结束后将发送系统通知。", flush=True)
time.sleep(seconds)
msg = f"{label} {minutes} 分钟已结束。"
with open(log_file, "a", encoding="utf-8") as f:
f.write(f"[结束] {msg}\n")
if do_notify:
notify_macos("静默番茄钟", msg)
print(f"[静默番茄钟] {msg}", flush=True)
return 0
if __name__ == "__main__":
sys.exit(main())

View File

@@ -0,0 +1,31 @@
# 专注静默WebPomodoro 静默控制)
> **静默原则**:不打开 WebPomodoro 图形界面,所有「开始专注 / 番茄钟」均通过命令行脚本完成。归属:卡罗帮。
---
## 触发
用户说 **专注、番茄钟、静默专注、开始专注、WebPomodoro、专注轻探、不打开界面计时** 等,且意图为「开始一段专注/番茄钟」时,走本 Skill。
---
## 执行(强制静默)
1. **禁止** 使用 `open -a WebPomodoro``open /Applications/WebPomodoro.app`(会打开界面,非静默)。
2. **一律** 调用静默脚本:
- 脚本路径:`运营中枢/工作台/卡罗帮/scripts/pomodoro_silent.py`
- 默认 25 分钟 + 结束时系统通知:
`python3 运营中枢/工作台/卡罗帮/scripts/pomodoro_silent.py --minutes 25 --notify`
- 指定 N 分钟:`--minutes N``-m N`
- 不弹通知:`--no-notify`
- 短休息 5 分钟:`--rest-short`;长休息 15 分钟:`--rest-long`
- 后台运行:命令末尾加 `&` 或使用 `nohup ... &`
3. 静默命令速查:`运营中枢/工作台/卡罗帮/WebPomodoro_功能与静默命令对照表.md`
方案说明:`运营中枢/工作台/卡罗帮/WebPomodoro_静默控制方案_idea.md`
---
## 小结
- 专注/番茄钟需求 → 只执行 `pomodoro_silent.py`,不打开任何 APP 界面,即**静默操作**。

View File

@@ -38,7 +38,7 @@
|:---|:---|
| **KR / KR_*** | 神射手 用户资产、估值等 |
| **wanzhi_esports** | 玩值电竞 App网站、API |
| **karuo_site** | 卡若ai网站官网与控制台全量数据:技能、网关、工作流、任务、用户、前端/后端配置等 |
| **karuo_site** | 卡若ai网站官网与控制台全量数据**卡若 AI 主库**:记忆条目、**对话记录**、**消息内容**聊天记录一律存此库、实时调用MongoDB 不可用时记忆降级 记忆.md、聊天降级 fallback/recent_chats_fallback.json |
| 其他业务库 | 按需在该实例下新建,不另起 MongoDB 容器 |
---
@@ -51,6 +51,23 @@
---
## 数据恢复与正确挂载(必读)
**唯一数据目录**:宿主机 `/Users/karuo/数据库/mongodb/data`(约 225GB。数据必须通过**宿主机路径挂载**,不能改用 Docker 命名卷,否则会看到“空库”。
**正确启动方式**(恢复或日常启动):
```bash
cd "/Users/karuo/Documents/开发/2、私域银行/数据中台/系统基座/config"
docker compose -f docker-compose-mongodb.yml up -d mongodb
```
**错误原因说明**:若用其他编排或 `docker run` 启动了同名容器且未挂载上述路径,而是用了 Docker 卷(如 `mongodb_data`),则容器内是空库,宿主机上的 200+GB 数据不会出现在库里。**务必只用数据中台这份 compose 起 datacenter_mongodb**。
**验证数据已挂载**`docker inspect datacenter_mongodb` 中应看到 `"/Users/karuo/数据库/mongodb/data" -> "/data/db"`
---
## 版本记录
| 日期 | 变更 |
@@ -59,3 +76,4 @@
| 2026-02-26 | 新增 datacenter 分组约定;所有数据库相关 Docker 项目归入 datacenterwebsite 通过 datacenter_network 连接 |
| 2026-02-27 | website 分组扩展卡若ai网站、玩值大屏、Soul 创业实验归入 website详见 `website分组清单.md` |
| 2026-03-01 | 新增库 karuo_site强制约定新生成数据/配置一律只放唯一 MongoDB不新建实例、不单独 27018 |
| 2026-03-19 | 恢复 225GB 数据:因容器曾用错误卷挂载导致“空库”;补充「数据恢复与正确挂载」说明,强制用数据中台 compose 启动 |

View File

@@ -32,6 +32,8 @@
|:---|:---|:---|
| 玩值电竞App | `wanzhi_esports` | 玩值电竞业务库集合与索引见《玩值电竞_数据库设计》连接串用本机统一 MongoDB。 |
| 卡若ai网站 | `karuo_site` | 官网与控制台全量数据技能、网关、工作流、任务、用户、frontend_config/backend_config 等);连接串用本机统一 MongoDB。 |
| Cursor/卡若AI 聊天记录 | `karuo_site`(对话记录、消息内容) | 聊天记录一律存 MongoDB实时调用不可用时用 fallback详见 `01_卡资/金仓_存储备份/聊天记录管理/SKILL.md`。 |
| 卡若AI 记忆条目 | `karuo_site`(记忆条目) | 长期记忆结构化存储(分类、标签、日期、内容);与 1、卡若本人/记忆.md 同步;详见 `02_卡人/水溪_整理归档/记忆系统/memory_mongo_schema.md`。 |
### MySQLdatacenter_mysql端口 3307归入 datacenter 编排)

View File

@@ -0,0 +1,81 @@
# 阿猫笔记本电脑 OpenClaw龙虾配置情况分析
> 分析依据卡若AI 工作台现有文档、阿猫 Mac 健康报告2026-03-04、ClawX/OpenClaw 网关部署说明。
> 分析时间2026-03-19
---
## 一、结论摘要
| 项目 | 情况 |
|------|------|
| **阿猫 Mac 上是否有 OpenClaw 网关** | **无**。现有 OpenClaw 网关部署在卡若本机(神射手 Docker 编排),端口 18789。 |
| **阿猫 Mac 上是否有 ClawX 客户端 / ~/.openclaw** | **文档未记录**。2026-03-04 健康报告中未提及 ClawX、OpenClaw 或 `~/.openclaw`。 |
| **若阿猫要用 OpenClaw/ClawX** | 二选一:**远程连卡若的网关**,或 **本机装 ClawX 并自启网关**(需配置 `~/.openclaw` 与模型 API。 |
---
## 二、当前 OpenClaw 架构(卡若侧)
- **网关部署位置**:卡若本机,`开发/2、私域银行/神射手` 目录下 `docker compose`,容器名 `website-openclaw-gateway`
- **端口**18789及 18790
- **网关地址**:本机访问为 `http://127.0.0.1:18789`
- **配置来源**:卡若本机 `~/.openclaw`(含 `openclaw.json`Docker 挂载该目录与 ClawX 共用。
- **鉴权**`~/.openclaw/openclaw.json``gateway.auth.token`(文档记录为 `clawx-c79e7d198b3c7c17057f7ff2caa52bdc`)。
- **ClawX 使用方式**:在**同一台机器**上关闭「自动启动网关」,网关地址填 `http://127.0.0.1:18789`Token 与上一致。详见《ClawX使用Docker网关说明》。
阿猫的 Macmacbook.quwanzhi.com用户 kr是**另一台机器**,无法直接访问卡若本机 127.0.0.1:18789除非通过内网/隧道/端口暴露。
---
## 三、阿猫 Mac 本机情况(来自健康报告)
- **主机**macbook.quwanzhi.com:22203用户 **kr**
- **用途**远程办公、飞书、Cursor、iCloud 同步婼瑄/卡若AI 等;**未提及** Docker、OpenClaw、ClawX、`~/.openclaw`
- **磁盘**:数据卷约 92% 占用,仅约 18 GB 可用,不适合再长期跑重型 Docker 服务。
- **结论**:当前**没有**在阿猫 Mac 上部署 OpenClaw 网关或单独为阿猫记录 ClawX/OpenClaw 配置若要用「龙虾」OpenClaw需按下面两种方式之一配置。
---
## 四、阿猫 Mac 使用 OpenClaw 的两种方式
### 方式 A远程连接卡若本机 OpenClaw 网关(推荐,无需在阿猫 Mac 跑网关)
1. **卡若本机**:保持神射手 Docker 中 `website-openclaw-gateway` 运行,并将 18789 对阿猫可达(例如 Tailscale、frp、或局域网 IP 端口转发)。阿猫 Mac 健康报告中有 ham0 25.30.239.48,若与卡若同处 Tailscale 等内网,可用卡若机器的 Tailscale IP + 18789。
2. **阿猫 Mac**
- 安装 **ClawX**(若未安装)。
- 关闭「自动启动网关」。
- 网关地址填:`http://<卡若机器IP或域名>:18789`(例如 `http://25.x.x.x:18789``http://某域名:18789`)。
- 鉴权 Token 与卡若本机 `~/.openclaw/openclaw.json``gateway.auth.token` 一致(见上文)。
3. **优点**:不占阿猫 Mac 磁盘与内存,模型、技能等沿用卡若侧配置。
4. **前提**:网络可达 + 卡若侧防火墙/路由器放行 18789或仅内网/VPN 访问)。
### 方式 B阿猫 Mac 本机安装 ClawX 并自启网关
1. **阿猫 Mac**:安装 ClawX开启「自动启动网关」由 ClawX 在本机启动 OpenClaw 网关进程。
2. **配置**:在本机创建并维护 `~/.openclaw/openclaw.json`(以及可选 `~/.openclaw/workspace/IDENTITY.md` 等),配置模型 API如 api123.icu Base URL + Token见《Claude_Code_api123配置说明》`gateway.auth.token` 等。
3. **缺点**:阿猫 Mac 磁盘已紧张(约 18 GB 可用)、内存 8 GB本机常驻网关会占资源且需单独维护一套模型与技能配置。
---
## 五、建议与后续可做事项
| 建议 | 说明 |
|------|------|
| **优先方式 A** | 在卡若侧暴露 18789仅内网/VPN阿猫 Mac 只装 ClawX 客户端并填远程网关地址 + Token无需在阿猫 Mac 跑网关。 |
| **确认阿猫是否已装 ClawX** | 可 SSH 到阿猫 Mac`ssh -p 22203 kr@macbook.quwanzhi.com`)执行:`ls -la ~/.openclaw 2>/dev/null || echo "无 .openclaw"``ls /Applications | grep -i claw`。 |
| **若采用方式 A** | 在 00_账号与API索引 或 本工作台 补充「阿猫 Mac ClawX 远程网关」一条:网关 URL、Token、使用场景仅内网/VPN。 |
| **若采用方式 B** | 可在阿猫 Mac 上复用《ClawX使用Docker网关说明》中的 Token 与配置结构,但 Base URL/模型 API 建议用 api123.icu 直连见《Claude_Code_api123配置说明》阿猫 Mac 一节)。 |
---
## 六、相关文档
- 《ClawX使用Docker网关说明》 ClawX 连本机 Docker OpenClaw 网关(卡若本机)
- 《ClawX_THINK模式与界面说明》`~/.openclaw/openclaw.json`、IDENTITY.md、控制台 18789
- 《阿猫Mac配置与健康分析_20260304》阿猫 Mac 硬件、磁盘、用途
- 《Claude_Code_api123配置说明》阿猫 Mac 默认 APIapi123.icu与 Token
---
*文档生成卡若AI 工作台。*

View File

@@ -8,12 +8,12 @@ CLAUDE_DIR="$HOME/.claude"
SETTINGS="$CLAUDE_DIR/settings.json"
BASE_URL="https://api123.icu"
API_KEY="sk-h7VW10iTSSXo6xJXe44nI1vUhsEcG3H8Z9XyFmWABvhaD4ZW"
MODEL="claude-sonnet-4-6"
# 使用 Sonnet 4.5 避免 api123 default 分组 5034.6 通道可能不可用)
MODEL="claude-sonnet-4-5-20250929"
mkdir -p "$CLAUDE_DIR"
# 保留已有配置,仅更新 api base 与 keyClaude Code 常用字段
# 保留已有配置,写入 CLI 用的 model/env 与旧版 anthropic* 字段
if [ -f "$SETTINGS" ]; then
# 用 Python 合并,避免 jq 依赖
python3 -c "
import json, os
p = '$SETTINGS'
@@ -23,8 +23,13 @@ if os.path.exists(p):
data = json.load(f)
data['anthropicBaseUrl'] = '$BASE_URL'
data['anthropicApiKey'] = '$API_KEY'
if 'defaultModel' not in data or not data.get('defaultModel'):
data['defaultModel'] = '$MODEL'
data['defaultModel'] = '$MODEL'
data['model'] = '$MODEL'
if 'env' not in data:
data['env'] = {}
data['env']['ANTHROPIC_API_KEY'] = '$API_KEY'
data['env']['ANTHROPIC_BASE_URL'] = '$BASE_URL'
data['env']['ANTHROPIC_MODEL'] = '$MODEL'
with open(p, 'w') as f:
json.dump(data, f, indent=2, ensure_ascii=False)
print('已更新:', p)
@@ -32,11 +37,17 @@ print('已更新:', p)
else
cat > "$SETTINGS" << EOF
{
"model": "$MODEL",
"anthropicBaseUrl": "$BASE_URL",
"anthropicApiKey": "$API_KEY",
"defaultModel": "$MODEL"
"defaultModel": "$MODEL",
"env": {
"ANTHROPIC_API_KEY": "$API_KEY",
"ANTHROPIC_BASE_URL": "$BASE_URL",
"ANTHROPIC_MODEL": "$MODEL"
}
}
EOF
echo "已创建: $SETTINGS"
fi
echo "api123.icu 已设为默认 API重启 Cursor/Claude Code 后生效。"
echo "api123.icu 已设为默认 API模型为 $MODEL(避免 503。请完全退出 Claude Code 后重新打开生效。"