Skip to content
Back to search

dontbesilent-skills

SkillGitHubIncomplete

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/dontbesilent2025--dbskill/badge.svg)](/listings/dontbesilent2025--dbskill)

HTML

<a href="/listings/dontbesilent2025--dbskill"><img src="/api/listings/dontbesilent2025--dbskill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 616 lines
  1. {
  2. "name": "dontbesilent-skills",
  3. "owner": {
  4. "name": "dontbesilent2025"
  5. },
  6. "metadata": {
  7. "description": "dontbesilent 商业与内容工具箱:37 个当前业务 Skill、2 个兼容入口和 1 个更新入口。",
  8. "version": "3.8.0"
  9. },
  10. "plugins": [
  11. {
  12. "name": "dbs",
  13. "description": "dontbesilent 商业工具箱的技能调度台,根据当前问题和反馈选择下一步,在对话中直接执行、澄清、组合或对照尝试 Skill。用户不知道从哪里开始、需要调整处理方法、第一次使用 dbskill、输入三位编号或查询隐藏款目录时使用;仅需推荐或可复制提示词时按请求交付。",
  14. "source": "./",
  15. "strict": true,
  16. "version": "3.8.0",
  17. "category": "business-diagnostics",
  18. "keywords": [
  19. "business",
  20. "router",
  21. "diagnosis",
  22. "toolkit",
  23. "chinese"
  24. ]
  25. },
  26. {
  27. "name": "dbs-update",
  28. "description": "更新官方 dbskill,并保留其他 Skill 与用户存档。用户要求更新、升级、检查 dbskill 版本,或在更新提醒后回复 1 时使用。",
  29. "source": "./skills/dbs-update",
  30. "strict": true,
  31. "version": "3.8.0",
  32. "category": "workflow-infrastructure",
  33. "keywords": [
  34. "dbskill",
  35. "update",
  36. "upgrade",
  37. "maintenance",
  38. "chinese"
  39. ]
  40. },
  41. {
  42. "name": "dbs-diagnosis",
  43. "description": "自动识别用户是在解决具体商业问题,还是希望全面检查商业模式,并进入对应诊断流程。用户希望拆解业务、检查商业模式或消解具体商业困境时使用。",
  44. "source": "./skills/dbs-diagnosis",
  45. "strict": true,
  46. "version": "3.8.0",
  47. "category": "business-diagnostics",
  48. "keywords": [
  49. "business-model",
  50. "diagnosis",
  51. "consulting",
  52. "problem-dissolution",
  53. "chinese"
  54. ]
  55. },
  56. {
  57. "name": "dbs-benchmark",
  58. "description": "用五重过滤法寻找值得模仿的对标,并排除主体差异造成的噪音。用户要求找对标、选择模仿对象或分析竞争参照时使用。",
  59. "source": "./skills/dbs-benchmark",
  60. "strict": true,
  61. "version": "3.8.0",
  62. "category": "business-diagnostics",
  63. "keywords": [
  64. "benchmark",
  65. "competitive-analysis",
  66. "imitation",
  67. "strategy",
  68. "chinese"
  69. ]
  70. },
  71. {
  72. "name": "dbs-standard-answer",
  73. "description": "围绕复杂问题先挖掘相关行业、学科、作者与可信理论,再比较结构同构的历史成功、失败和反例,提炼带条件的标准答案。用户需要同时获得理论解释与历史比较,或明确询问历史上如何解决、有没有经典解法、标准答案时使用;只需给现有命题、案例、PPT 或方法论找理论依据时不使用。",
  74. "source": "./skills/dbs-standard-answer",
  75. "strict": true,
  76. "version": "3.8.0",
  77. "category": "thinking-tools",
  78. "keywords": [
  79. "theory-grounding",
  80. "theory-application",
  81. "knowledge-discovery",
  82. "history",
  83. "analogy",
  84. "standard-answer",
  85. "case-study",
  86. "decision",
  87. "chinese"
  88. ]
  89. },
  90. {
  91. "name": "dbs-theory-grounding",
  92. "description": "理论溯源与案例重释。审查 PPT、课程、文案或方法论中的经验判断,先判断命题是否成立,再匹配并核实可信理论,用该理论重释案例并标明边界。适用于给自创理论找依据、给 PPT 补理论来源、判断一句话能否上升为理论、检查是否硬套名人;聚焦单次理论锚定,不默认展开历史同构研究。",
  93. "source": "./skills/dbs-theory-grounding",
  94. "strict": true,
  95. "version": "3.8.0",
  96. "category": "thinking-tools",
  97. "keywords": [
  98. "theory-grounding",
  99. "source-verification",
  100. "theory-application",
  101. "ppt",
  102. "methodology",
  103. "chinese"
  104. ]
  105. },
  106. {
  107. "name": "dbs-action",
  108. "description": "用阿德勒心理学框架诊断执行阻滞。用户知道该做什么却迟迟不做、反复拖延或行动中断时使用。",
  109. "source": "./skills/dbs-action",
  110. "strict": true,
  111. "version": "3.8.0",
  112. "category": "business-diagnostics",
  113. "keywords": [
  114. "psychology",
  115. "execution",
  116. "procrastination",
  117. "adler",
  118. "chinese"
  119. ]
  120. },
  121. {
  122. "name": "dbs-content",
  123. "description": "围绕已经确定的选题诊断内容怎么组织、论证和表达,形成创作方案。用户要把选题做成内容时使用;不负责已有稿件的逐句删改和标题开头成稿。",
  124. "source": "./skills/dbs-content",
  125. "strict": true,
  126. "version": "3.8.0",
  127. "category": "content-creation",
  128. "keywords": [
  129. "content",
  130. "creation",
  131. "copywriting",
  132. "social-media",
  133. "chinese"
  134. ]
  135. },
  136. {
  137. "name": "dbs-content-value",
  138. "description": "评估发布前或低流量内容会吸引谁、开头能否留人,以及流量和商业价值。适用于整体内容表现判断;不负责传播机制解读或整篇逐句改稿。",
  139. "source": "./skills/dbs-content-value",
  140. "strict": true,
  141. "version": "3.8.0",
  142. "category": "content-creation",
  143. "keywords": [
  144. "content-value",
  145. "audience",
  146. "traffic",
  147. "commercial-value",
  148. "creator",
  149. "chinese"
  150. ]
  151. },
  152. {
  153. "name": "dbs-content-risk-check",
  154. "description": "面向创作者的内容发布风险检查。逐句检查自媒体、社交媒体和内容平台的标题、正文、图片文字、字幕、口播、评论、账号资料及视频画面,分别判断平台机器可能识别什么、内容本身存在什么实质问题,并给出具体位置和最小修改动作;需要明确视频语境边界时,额外生成真实准确的三行贴片小字。用户询问「检查敏感词」「发布前排雷」「这篇内容哪里可能违规」「这条小红书能不能发」「视频上放什么声明」时使用。保留强观点、情绪张力、个人风格和传播钩子。",
  155. "source": "./skills/dbs-content-risk-check",
  156. "strict": true,
  157. "version": "3.8.0",
  158. "category": "content-creation",
  159. "keywords": [
  160. "content-risk",
  161. "moderation",
  162. "compliance",
  163. "creator",
  164. "xiaohongshu",
  165. "chinese"
  166. ]
  167. },
  168. {
  169. "name": "dbs-content-system",
  170. "description": "把本地文稿、推文、选题、案例和课程稿整理成可持续生长、可重组复用的内容工程。用户要求结构化内容资产、整理旧素材或建立主题地图时使用。",
  171. "source": "./skills/dbs-content-system",
  172. "strict": true,
  173. "version": "3.8.0",
  174. "category": "workflow-infrastructure",
  175. "keywords": [
  176. "content-system",
  177. "knowledge-project",
  178. "obsidian",
  179. "asset-structuring",
  180. "agent-workflow",
  181. "chinese"
  182. ]
  183. },
  184. {
  185. "name": "dbs-video-extract",
  186. "description": "从抖音、小红书、微信视频号等平台链接或分享文案查询作品/账号数据并提取语音文字稿,按作者和标题归档为 Markdown。用户要求解析平台视频或取得数据、文字稿时使用;需配置 TikHub 与轻抖凭证,不负责本地成片章节导航或导航视频渲染。",
  187. "source": "./skills/dbs-video-extract",
  188. "strict": true,
  189. "version": "3.8.0",
  190. "category": "content-creation",
  191. "keywords": [
  192. "video-extract",
  193. "transcription",
  194. "douyin",
  195. "xiaohongshu",
  196. "wechat-channels",
  197. "tikhub",
  198. "qingdou",
  199. "chinese"
  200. ]
  201. },
  202. {
  203. "name": "dbs-video-navigation",
  204. "description": "根据本地视频或带时间戳字幕划分章节、话题或步骤,生成可导入剪辑软件的导航条 MP4、动态分段进度和时间表。用户要求视频章节导航、顶部进度条或当前位置提示时使用;不负责平台链接数据提取或标题封面开头文案。",
  205. "source": "./skills/dbs-video-navigation",
  206. "strict": true,
  207. "version": "3.8.0",
  208. "category": "content-creation",
  209. "keywords": [
  210. "video-navigation",
  211. "chapters",
  212. "progress-bar",
  213. "subtitles",
  214. "timeline"
  215. ]
  216. },
  217. {
  218. "name": "dbs-knowledge",
  219. "description": "把本地文件夹建成 Agent 可稳定查找、收录和维护的知识库,并支持导航、版本判断、健康检查及 SOT 分层治理。用户要求搭建、查询、更新、整理或瘦身知识库时使用。",
  220. "source": "./skills/dbs-knowledge",
  221. "strict": true,
  222. "version": "3.8.0",
  223. "category": "workflow-infrastructure",
  224. "keywords": [
  225. "knowledge-base",
  226. "folder",
  227. "source-of-truth",
  228. "local-files",
  229. "agent-workflow",
  230. "chinese"
  231. ]
  232. },
  233. {
  234. "name": "dbs-title-cover-intro",
  235. "description": "为短视频、图文和文章生成或修改文字标题、封面文字和视频开头。先按稿件与拍摄状态把素材扩展成面向不同人群的选题供用户挑选,并询问能让观众相信作者的经历或数字,再一屏交付小红书、B 站、抖音、视频号的标题、封面与开头。用户要写标题、封面文字、开头、冷开场或多平台适配时使用;不生成封面图片或发布风险声明。",
  236. "source": "./skills/dbs-title-cover-intro",
  237. "strict": true,
  238. "version": "3.8.0",
  239. "category": "content-creation",
  240. "keywords": [
  241. "title",
  242. "cover",
  243. "video",
  244. "intro",
  245. "hook",
  246. "opening",
  247. "social-media",
  248. "chinese"
  249. ]
  250. },
  251. {
  252. "name": "dbs-deconstruct",
  253. "description": "用维特根斯坦与奥派经济学方法拆解模糊的商业概念。用户要求解释一个词、澄清概念边界或识别概念混用时使用。",
  254. "source": "./skills/dbs-deconstruct",
  255. "strict": true,
  256. "version": "3.8.0",
  257. "category": "thinking-tools",
  258. "keywords": [
  259. "wittgenstein",
  260. "concepts",
  261. "deconstruction",
  262. "philosophy",
  263. "chinese"
  264. ]
  265. },
  266. {
  267. "name": "dbs-chatroom-austrian",
  268. "description": "由哈耶克、米塞斯与 Claude 从奥派经济学视角展开多角色讨论。用户要求进入奥派聊天室或用奥派分析问题时使用。",
  269. "source": "./skills/dbs-chatroom-austrian",
  270. "strict": true,
  271. "version": "3.8.0",
  272. "category": "thinking-tools",
  273. "keywords": [
  274. "austrian-economics",
  275. "hayek",
  276. "mises",
  277. "debate",
  278. "philosophy",
  279. "chinese"
  280. ]
  281. },
  282. {
  283. "name": "dbs-chatroom",
  284. "description": "根据话题推荐或接受用户指定的专家,模拟多角色对话并总结分歧。用户要求专家讨论、定向聊天室或继续当前讨论时使用。",
  285. "source": "./skills/dbs-chatroom",
  286. "strict": true,
  287. "version": "3.8.0",
  288. "category": "thinking-tools",
  289. "keywords": [
  290. "chatroom",
  291. "multi-expert",
  292. "debate",
  293. "recommendation",
  294. "chinese"
  295. ]
  296. },
  297. {
  298. "name": "dbs-ai-check",
  299. "description": "扫描公众号长文、短视频文稿、推文等文案中的 AI 写作特征并输出检测报告,默认只诊断不改写;用户看完报告说「我想改」后,逐条追问写法背后的意图并给出修改方向。用户要求检查 AI 味、AI 痕迹或机器化表达时使用。",
  300. "source": "./skills/dbs-ai-check",
  301. "strict": true,
  302. "version": "3.8.0",
  303. "category": "content-creation",
  304. "keywords": [
  305. "ai-detection",
  306. "writing",
  307. "fingerprint",
  308. "content-quality",
  309. "chinese"
  310. ]
  311. },
  312. {
  313. "name": "dbs-plain-writing",
  314. "description": "按事实与功能顺序直接撰写、改写或检查产品、工具、功能、项目和更新说明,内置 ASD-STE100 清晰表达原则,核对主体、动作、指代、术语、条件与承诺强度,保留原意和用户锁定的文字,不加营销钩子、痛点渲染和抽象包装。用户要求平铺直叙地写、不要营销腔、把能力逐条写清、检查措辞歧义或只改指定一处时使用;中文为原则适配,不等于官方符合性认证。",
  315. "source": "./skills/dbs-plain-writing",
  316. "strict": true,
  317. "version": "3.8.0",
  318. "category": "content-creation",
  319. "keywords": [
  320. "writing",
  321. "plain-language",
  322. "asd-ste100",
  323. "documentation",
  324. "chinese"
  325. ]
  326. },
  327. {
  328. "name": "dbs-speak-human",
  329. "description": "说人话:把要发给真人看的中文,例如微信消息、群聊开场、顾客回复、私信和 Agent 回给用户的话,写成或改成像真人随口说的口语,用户提供本人写过的话时参照其口吻,去掉书面腔、客服腔和 AI 味,保留原意、事实和用户锁定的文字;调用后,本次对话里 Agent 的回复也按这套标准写。用户说「说人话」「太 AI 了」「改得口语一点」「帮我写条微信」时使用;不用于产品说明文和公众号长文,也不出 AI 痕迹检测报告。",
  330. "source": "./skills/dbs-speak-human",
  331. "strict": true,
  332. "version": "3.8.0",
  333. "category": "content-creation",
  334. "keywords": [
  335. "writing",
  336. "conversation",
  337. "plain-language",
  338. "ai-detection",
  339. "chinese"
  340. ]
  341. },
  342. {
  343. "name": "dbs-wechat-html",
  344. "description": "把 Markdown 转成可粘贴到微信公众号后台的 HTML,并提供 15 种内置风格。用户要求生成公众号 HTML、制作微信版本或排版公众号文章时使用。",
  345. "source": "./skills/dbs-wechat-html",
  346. "strict": true,
  347. "version": "3.8.0",
  348. "category": "content-creation",
  349. "keywords": [
  350. "wechat",
  351. "official-account",
  352. "html",
  353. "markdown",
  354. "publishing",
  355. "chinese"
  356. ]
  357. },
  358. {
  359. "name": "dbs-install-skill",
  360. "description": "将单个 Skill 或 Skill 集合安装到通用 Agents、Claude Code、Codex、WorkBuddy、Grok、Hermes Agent、Kiro、Qwen Code、Cline 等 Agent。用户要求跨 Agent 安装、同步、查看、去重或卸载 Skill 时使用。",
  361. "source": "./skills/dbs-install-skill",
  362. "strict": true,
  363. "version": "3.8.0",
  364. "category": "workflow-infrastructure",
  365. "keywords": [
  366. "install",
  367. "uninstall",
  368. "symlink",
  369. "claude-code",
  370. "codex",
  371. "workbuddy",
  372. "doubao",
  373. "agents",
  374. "skill-management",
  375. "chinese"
  376. ]
  377. },
  378. {
  379. "name": "dbs-skill-maker",
  380. "description": "制作新 Skill,或改进已有 Skill。先按改动规模给出方案并等待确认,再生成或修改文件,并用真实任务对比改动前后的表现。用户要求做 Skill、把反复出现的问题沉淀成 Skill、修改或修复 Skill、根据失败案例改进 Skill、检查或测试 Skill 时使用;只有用户明确要求分享或发布时,才准备 GitHub 仓库并验证 `npx skills add`。",
  381. "source": "./skills/dbs-skill-maker",
  382. "strict": true,
  383. "version": "3.8.0",
  384. "category": "workflow-infrastructure",
  385. "keywords": [
  386. "skill",
  387. "skill-creator",
  388. "skill-improvement",
  389. "requirements",
  390. "evaluation",
  391. "github",
  392. "agent",
  393. "chinese"
  394. ]
  395. },
  396. {
  397. "name": "dbs-human-dispatch",
  398. "description": "当用户希望将任务交给员工或协作者并跟进结果时,结合本地人员资料选择负责人,写清要求、协商工期、提供帮助并验收汇报;有飞书 CLI 时派单、读取回填和回复,缺少工具或权限时交付可转发文字。支持事件队列与可配置 Agent 接入,不承担招聘、绩效排名或惩罚。",
  399. "source": "./skills/dbs-human-dispatch",
  400. "strict": true,
  401. "version": "3.8.0",
  402. "category": "workflow-infrastructure",
  403. "keywords": [
  404. "delegation",
  405. "human-collaboration",
  406. "feishu",
  407. "task-management",
  408. "chinese"
  409. ]
  410. },
  411. {
  412. "name": "dbs-save",
  413. "description": "把当前诊断的关键状态保存到本地,并查看或设置存档位置。用户要求保存结论、跨会话续接或修改存档位置时使用。",
  414. "source": "./skills/dbs-save",
  415. "strict": true,
  416. "version": "3.8.0",
  417. "category": "state-management",
  418. "keywords": [
  419. "save",
  420. "checkpoint",
  421. "snapshot",
  422. "state",
  423. "persistence",
  424. "chinese"
  425. ]
  426. },
  427. {
  428. "name": "dbs-restore",
  429. "description": "恢复由 dbs-save 保存的最近诊断状态。用户要求接着上次、查看此前结论或继续未完成诊断时使用。",
  430. "source": "./skills/dbs-restore",
  431. "strict": true,
  432. "version": "3.8.0",
  433. "category": "state-management",
  434. "keywords": [
  435. "restore",
  436. "recall",
  437. "continue",
  438. "session",
  439. "chinese"
  440. ]
  441. },
  442. {
  443. "name": "dbs-report",
  444. "description": "把多次 dbs-save 存档合并成可交付的 Markdown 报告。用户要求汇总诊断、整理报告或生成可分享材料时使用。",
  445. "source": "./skills/dbs-report",
  446. "strict": true,
  447. "version": "3.8.0",
  448. "category": "state-management",
  449. "keywords": [
  450. "report",
  451. "deliverable",
  452. "merge",
  453. "markdown",
  454. "chinese"
  455. ]
  456. },
  457. {
  458. "name": "dbs-goal",
  459. "description": "提取已有约束,只追问影响执行或验收的信息,把模糊愿望整理成可行动、可检查的交付目标。用户要明确做成什么、边界和验收标准时使用;不替代概念拆解或研究问题改写。",
  460. "source": "./skills/dbs-goal",
  461. "strict": true,
  462. "version": "3.8.0",
  463. "category": "business-diagnostics",
  464. "keywords": [
  465. "goal",
  466. "clarity",
  467. "wittgenstein",
  468. "language-game",
  469. "chinese"
  470. ]
  471. },
  472. {
  473. "name": "dbs-good-question",
  474. "description": "把模糊提问改写成 Agent 可推理、可批评、可验证的问题说明书,并判断自动化可解程度。用户要改进问题表述、研究问题或评估 Agent 可解性时使用;任务交付目标已明确时不重复澄清目标。",
  475. "source": "./skills/dbs-good-question",
  476. "strict": true,
  477. "version": "3.8.0",
  478. "category": "thinking-tools",
  479. "keywords": [
  480. "problem",
  481. "question",
  482. "agent",
  483. "automation",
  484. "explanation",
  485. "hard-to-vary",
  486. "chinese"
  487. ]
  488. },
  489. {
  490. "name": "dbs-jtbd",
  491. "description": "用 Jobs to Be Done 识别具体情境中用户想推进的进展、切换方案的力量和选择标准,解释产品、服务或内容为何被选择。用户要求分析顾客任务、购买动机、替代方案或明确用 JTBD 重写提示词时使用;普通任务验收标准澄清无需套用该框架。",
  492. "source": "./skills/dbs-jtbd",
  493. "strict": true,
  494. "version": "3.8.0",
  495. "category": "thinking-tools",
  496. "keywords": [
  497. "jtbd",
  498. "jobs-to-be-done",
  499. "user-needs",
  500. "product-strategy",
  501. "decision",
  502. "chinese"
  503. ]
  504. },
  505. {
  506. "name": "dbs-decision",
  507. "description": "把需要长期跟踪的业务、关系、健康、职业、学习或投资问题建成本地决策知识工程。用户要求决策立案、结果回填、状态画像或长期复盘时使用。",
  508. "source": "./skills/dbs-decision",
  509. "strict": true,
  510. "version": "3.8.0",
  511. "category": "state-management",
  512. "keywords": [
  513. "decision",
  514. "tracking",
  515. "knowledge-project",
  516. "personal",
  517. "snapshot",
  518. "concept-library",
  519. "chinese"
  520. ]
  521. },
  522. {
  523. "name": "dbs-learning",
  524. "description": "把课题拆成连续学习文章,并根据用户反馈调整后续深度、角度和节奏。用户要求系统学习一个主题、继续下一篇或按反馈调整课程时使用。",
  525. "source": "./skills/dbs-learning",
  526. "strict": true,
  527. "version": "3.8.0",
  528. "category": "learning",
  529. "keywords": [
  530. "learning",
  531. "course",
  532. "adaptive-learning",
  533. "feedback",
  534. "chinese"
  535. ]
  536. },
  537. {
  538. "name": "dbs-spread",
  539. "description": "解释一段已有内容为什么引发共鸣、情绪或分享,识别传播机制、有效立场和受众动机,并提炼讨论方向。适用于传播机制解读;不负责整篇逐句改稿或整体流量和商业价值评估。",
  540. "source": "./skills/dbs-spread",
  541. "strict": true,
  542. "version": "3.8.0",
  543. "category": "content-creation",
  544. "keywords": [
  545. "content",
  546. "psychology",
  547. "transmission",
  548. "resonance",
  549. "chinese"
  550. ]
  551. },
  552. {
  553. "name": "dbs-resonate",
  554. "description": "诊断已经写成的稿件哪里没有打中目标受众,结合原句解释共鸣断点并提出具体删改建议。适用于稿件修订;不负责整体流量与商业价值评估,也不以解释已发布内容的传播机制为主要交付。",
  555. "source": "./skills/dbs-resonate",
  556. "strict": true,
  557. "version": "3.8.0",
  558. "category": "content-creation",
  559. "keywords": [
  560. "draft",
  561. "resonance",
  562. "content",
  563. "diagnosis",
  564. "chinese"
  565. ]
  566. },
  567. {
  568. "name": "dbs-script-flow",
  569. "description": "检查短视频逐字稿的段落衔接、信息密度和口播流畅度,定位观众可能划走的位置。用户要求检查逻辑延续、文稿顺畅度或流失风险时使用。",
  570. "source": "./skills/dbs-script-flow",
  571. "strict": true,
  572. "version": "3.8.0",
  573. "category": "content-creation",
  574. "keywords": [
  575. "script",
  576. "flow",
  577. "continuity",
  578. "completion-rate",
  579. "short-video",
  580. "chinese"
  581. ]
  582. },
  583. {
  584. "name": "dbs-sync-to-dondon",
  585. "description": "同步给 dondon:读取本机 Claude Code、Codex、WorkBuddy、Grok 最近的聊天记录,在本地隐去敏感信息后写成 800 字以内的工作近况,并找出聊天里用到的文档;用户确认后推给 dondon bot(未配置推送的复制给用户粘贴),让它的早报和提醒贴着用户手上的事;用户同意后可每天自动同步(由 bot 那边写近况,本机不需要 Agent 在场)。用户说「同步给 dondon」「把近况发给 bot」「开启/停止自动同步」「sync to dondon」时使用;不上传密钥密码,聊天摘录只在用户同意的自动同步里上传。",
  586. "source": "./skills/dbs-sync-to-dondon",
  587. "strict": true,
  588. "version": "3.8.0",
  589. "category": "workflow-infrastructure",
  590. "keywords": [
  591. "dondon",
  592. "sync",
  593. "agent-history",
  594. "bot",
  595. "chinese"
  596. ]
  597. },
  598. {
  599. "name": "dbs-computer-use",
  600. "description": "一个入口操控电脑,适用于 macOS、Windows、Linux 和各种 Agent:先判断要不要点界面,再按当前工具清单选路线(Cua Driver 优先,agent-desktop 兜底,Agent 自带的 computer use 第三),缺工具时说明装了能做到什么并给出官方安装命令,经同意再装;尽量后台操作、不抢鼠标,敏感动作先确认,操作后读回。用户说「在电脑上帮我…」「去浏览器里看看…」「操作这个 App」「computer use」时使用;不替用户输入密码或付款,不用 Claude in Chrome。触发:/dbs-computer-use。",
  601. "source": "./skills/dbs-computer-use",
  602. "strict": true,
  603. "version": "3.8.0",
  604. "category": "workflow-infrastructure",
  605. "keywords": [
  606. "computer-use",
  607. "desktop-automation",
  608. "browser",
  609. "macos",
  610. "windows",
  611. "linux",
  612. "chinese"
  613. ]
  614. }
  615. ]
  616. }
README.md · README · 298 lines
  1. # dbskill
  2. 简体中文 | [English](README.en.md) | [日本語](README.ja.md) | [한국어](README.ko.md) | [繁體中文](README.zh-TW.md)
  3. [![Version](https://img.shields.io/badge/version-3.8.0-2563EB.svg?style=flat-square)](VERSION)
  4. [![skills.sh](https://skills.sh/b/dontbesilent2025/dbskill)](https://skills.sh/b/dontbesilent2025/dbskill)
  5. [![License](https://img.shields.io/badge/license-All%20Rights%20Reserved-16A34A.svg?style=flat-square)](LICENSE)
  6. **本次更新:** 安装 Skill 时可自动同步到 Antigravity 的全局目录,供各工作区调用。
  7. ## dbskill 是什么
  8. dbskill 是 dontbesilent 制作的中文 AI Skills 工具箱,共 37 个 Skill。安装到豆包、WorkBuddy、Claude Code、Codex 等支持 Skills 的 Agent 后,可以在对话里直接使用
  9. Skill 是一套写给 Agent 的做事方法。装好 dbskill 后,你可以让 Agent:
  10. - 判断一门生意的问题出在哪,比如续费低、客户嫌贵
  11. - 找值得学的同行,看对方具体怎么做
  12. - 把一个选题做成内容方案,检查稿子哪里没打动人
  13. - 给一条视频写标题、封面文字和开头,发布前检查有没有违规风险
  14. - 分析自己为什么知道该做却一直没做
  15. - 把本地文件夹整理成可以随时查询的知识库
  16. 方法资料来自 dontbesilent 的 16,152 条公开推文,整理成 4,176 个知识原子。作者:[@dontbesilent](https://x.com/dontbesilent)
  17. ## 快速开始
  18. **第 1 步:安装**
  19. 在终端运行:
  20. ```bash
  21. npx -y skills add dontbesilent2025/dbskill -g --all
  22. ```
  23. 使用 Claude Code 插件市场或只装单个 Skill,见下文[安装详情](#安装详情)
  24. 在 Grok Bot 里使用:直接添加现成的 [dbs 创业教练](https://x.ai/bot/kpZtlm5CADHoXaaAqTV5Z) 或 [dbs 内容教练](https://x.ai/bot/qonh7lyBBYsbUXsR9LtO2),用法见[在 Grok Bot 里使用](#在-grok-bot-里使用)
  25. **第 2 步:把问题交给 `/dbs`**
  26. 在 Agent 对话框输入 `/dbs`,后面写上你的情况和问题。信息不完整也可以:
  27. ```text
  28. /dbs 我做少儿编程课,有 40 个付费学员,但续费率很低。我不知道该先检查产品、定价还是客户匹配
  29. ```
  30. 第一次使用,可以先输入 `/dbs 新手入门`,了解能处理哪些任务
  31. **第 3 步:在同一个对话里继续**
  32. 收到结果后,直接补充事实、材料或修改意见,不用重新输入命令。换一个新目标时,再输入一次 `/dbs`
  33. ## 在 Grok Bot 里使用
  34. 在 Grok Bot 里不用敲命令,直接添加现成的教练。第一次聊天时,它会自己装好 dbskill
  35. | 教练 | 能帮你做什么 | 添加链接 |
  36. | --- | --- | --- |
  37. | dbs 创业教练 | 想清楚生意卡在哪、这周先做哪一件事;愿意的话,每周一主动找你复盘 | https://x.ai/bot/kpZtlm5CADHoXaaAqTV5Z |
  38. | dbs 内容教练 | 定选题,写标题、封面和开头,检查稿子,复盘每条内容的表现;愿意的话,每周五主动找你复盘 | https://x.ai/bot/qonh7lyBBYsbUXsR9LtO2 |
  39. **怎么用**
  40. 1. 打开上面的链接,点「Add to Grok Bot」,在 Grok Bot App 里确认添加
  41. 2. 给新添加的教练发一句「你好」。它会先花几分钟装好 dbskill,再问你几个关于生意或账号的问题
  42. 3. 之后直接说你的问题,例如「我的课续费率很低,先查哪里」「帮我给这条视频想个标题」
  43. **教练说装不上时**
  44. 把下面这段原样发给它。用内容教练的,把最后的 `startup` 换成 `content`:
  45. ```text
  46. 请在你的运行环境里执行下面两条命令安装 dbskill,把输出原样告诉我:
  47. git clone --depth 1 https://github.com/dontbesilent2025/dbskill /tmp/dbskill 2>/dev/null || git -C /tmp/dbskill pull --ff-only
  48. python3 /tmp/dbskill/tools/grok/install.py --coach startup
  49. ```
  50. 不用教练、只想在自己的 Grok Bot 里装 dbskill,也发这段,把 `startup` 换成 `all`,会装好全部 29 个公开 Skill
  51. ## /dbs 怎样安排 Skill
  52. `/dbs` 是 dbskill 的技能调度台。它先看你要的最终结果,再决定用哪几个 Skill、按什么顺序用。能少用就少用:简单问题直接回答,一个 Skill 够用就只用一个
  53. 常见的安排有 6 种:
  54. 1. **只用一个**:诊断商业模式,只用 `dbs-diagnosis`
  55. 2. **按顺序接着做**:后一步要用前一步的结果。`dbs-content` 给出创作方案,你写完稿子,再用 `dbs-content-risk-check` 检查发布风险
  56. 3. **各做各的**:几件事互不相关。`dbs-ai-check` 查 AI 味,`dbs-wechat-html` 排版,两份结果分别交给你
  57. 4. **先判断,再决定做不做**:`dbs-content-value` 先判断选题值不值得做,值得再用 `dbs-content` 出方案
  58. 5. **分别分析,再比较**:同一个问题可能有几种原因。稿子流量低,`dbs-content-value` 和 `dbs-resonate` 各自给出原因,`/dbs` 再比较
  59. 6. **做完检查,再修改**:要求高的文字,`dbs-plain-writing` 写完后用 `dbs-ai-check` 检查,再按问题修改
  60. 需要你定方向时,`/dbs` 会把选项列给你,不替你选。开始前,它会说明打算怎么安排、为什么这样安排
  61. ## 全部 Skill
  62. 已经知道要用哪个 Skill 时,可以直接输入它的命令。每个 Skill 的适用时机、输入示例和边界,见[新手入门与 Skill 全目录](docs/新手入门.md#skill-全目录)
  63. ### 入口
  64. | 命令 | 用途 |
  65. | --- | --- |
  66. | [`/dbs`](skills/dbs/SKILL.md) | 根据你的问题选择和安排 Skill,在当前对话里推进 |
  67. ### 商业判断与问题澄清
  68. | 命令 | 用途 |
  69. | --- | --- |
  70. | [`/dbs-diagnosis`](skills/dbs-diagnosis/SKILL.md) | 判断一个商业问题是否成立,或全面检查一门生意,给出明天要做的第一件事 |
  71. | [`/dbs-benchmark`](skills/dbs-benchmark/SKILL.md) | 筛选值得模仿的同行,拆出对方获客、转化、交付的具体做法 |
  72. | [`/dbs-jtbd`](skills/dbs-jtbd/SKILL.md) | 分析顾客为什么选择或放弃一个产品 |
  73. | [`/dbs-goal`](skills/dbs-goal/SKILL.md) | 把模糊的愿望整理成能检查的目标和完成标准 |
  74. | [`/dbs-good-question`](skills/dbs-good-question/SKILL.md) | 把模糊的问题改写清楚,判断哪些部分能交给 Agent |
  75. | [`/dbs-deconstruct`](skills/dbs-deconstruct/SKILL.md) | 拆解一个说不清的概念,讲清它在不同场合的意思 |
  76. | [`/dbs-theory-grounding`](skills/dbs-theory-grounding/SKILL.md) | 检查课程、PPT 或方法论里的判断,找到可信的理论依据 |
  77. | [`/dbs-standard-answer`](skills/dbs-standard-answer/SKILL.md) | 研究一个问题的相关理论和历史案例,给出带条件的标准答案 |
  78. ### 内容创作与发布
  79. | 命令 | 用途 |
  80. | --- | --- |
  81. | [`/dbs-content`](skills/dbs-content/SKILL.md) | 把已定的选题做成内容方案:形式、平台、结构和表达 |
  82. | [`/dbs-title-cover-intro`](skills/dbs-title-cover-intro/SKILL.md) | 先定选题,再写小红书、B 站、抖音、视频号的标题、封面文字和开头 |
  83. | [`/dbs-resonate`](skills/dbs-resonate/SKILL.md) | 找出写好的稿子哪里没打动目标受众,给出删改建议 |
  84. | [`/dbs-script-flow`](skills/dbs-script-flow/SKILL.md) | 检查短视频逐字稿的衔接和口播流畅度,标出观众可能划走的位置 |
  85. | [`/dbs-content-value`](skills/dbs-content-value/SKILL.md) | 判断内容会吸引谁、开头能不能留住人,以及可能的流量和商业价值 |
  86. | [`/dbs-spread`](skills/dbs-spread/SKILL.md) | 解释一条已有反响的内容为什么让人共鸣或转发 |
  87. | [`/dbs-ai-check`](skills/dbs-ai-check/SKILL.md) | 标出文案里的 AI 写作痕迹 |
  88. | [`/dbs-content-risk-check`](skills/dbs-content-risk-check/SKILL.md) | 发布前逐句检查平台审核风险,给出最小的修改方法 |
  89. | [`/dbs-plain-writing`](skills/dbs-plain-writing/SKILL.md) | 按事实顺序写产品、功能和更新说明,不加营销包装 |
  90. | [`/dbs-speak-human`](skills/dbs-speak-human/SKILL.md) | 把微信消息、顾客回复和 Agent 的回复改成像真人随口说的口语 |
  91. | [`/dbs-wechat-html`](skills/dbs-wechat-html/SKILL.md) | 把 Markdown 排成能粘贴到公众号后台的 HTML |
  92. ### AI 味三件套
  93. 觉得文字「太 AI」时,先分清这段文字给谁看,再选 Skill:
  94. | 命令 | 处理什么文字 | 交给你什么 |
  95. | --- | --- | --- |
  96. | [`/dbs-ai-check`](skills/dbs-ai-check/SKILL.md) | 公众号长文、短视频文稿、推文 | 检测报告,逐处标出 AI 写作特征;你说「我想改」后逐条追问你本来想怎么说,不直接替你重写 |
  97. | [`/dbs-speak-human`](skills/dbs-speak-human/SKILL.md) | 微信消息、群聊开场、顾客回复、私信、Agent 回给你的话 | 改好的全文,附每处改动和原因 |
  98. | [`/dbs-plain-writing`](skills/dbs-plain-writing/SKILL.md) | 产品、功能、项目和更新说明 | 按事实顺序写成的成稿,不加营销包装 |
  99. ### 视频处理
  100. | 命令 | 用途 |
  101. | --- | --- |
  102. | [`/dbs-video-extract`](skills/dbs-video-extract/SKILL.md) | 根据平台链接取得作品数据和语音文字稿;需要外部服务凭证 |
  103. | [`/dbs-video-navigation`](skills/dbs-video-navigation/SKILL.md) | 为本地视频划分章节,生成可导入剪辑软件的导航条 |
  104. ### 行动、学习与决策
  105. | 命令 | 用途 |
  106. | --- | --- |
  107. | [`/dbs-action`](skills/dbs-action/SKILL.md) | 分析知道该做却一直没做的原因,给出今天能做的一步 |
  108. | [`/dbs-learning`](skills/dbs-learning/SKILL.md) | 把一个课题拆成连续的学习文章,按你的反馈调整下一篇 |
  109. | [`/dbs-decision`](skills/dbs-decision/SKILL.md) | 为需要长期跟踪的决策建立本地记录,之后回填结果和复盘 |
  110. ### 存档与报告
  111. | 命令 | 用途 |
  112. | --- | --- |
  113. | [`/dbs-save`](skills/dbs-save/SKILL.md) | 把当前对话的结论和下一步保存到本机 |
  114. | [`/dbs-restore`](skills/dbs-restore/SKILL.md) | 读取上次的存档,接着处理 |
  115. | [`/dbs-report`](skills/dbs-report/SKILL.md) | 把多份存档合并成一份报告 |
  116. ### 多视角讨论
  117. | 命令 | 用途 |
  118. | --- | --- |
  119. | [`/dbs-chatroom`](skills/dbs-chatroom/SKILL.md) | 请几位专家角色围绕一个话题分别发言,最后汇总 |
  120. | [`/dbs-chatroom-austrian`](skills/dbs-chatroom-austrian/SKILL.md) | 用哈耶克、米塞斯两位奥派经济学家的视角讨论问题 |
  121. ### 资料与工具
  122. | 命令 | 用途 |
  123. | --- | --- |
  124. | [`/dbs-knowledge`](skills/dbs-knowledge/SKILL.md) | 把本地文件夹建成 Agent 能查找、收录和维护的知识库 |
  125. | [`/dbs-content-system`](skills/dbs-content-system/SKILL.md) | 把一批旧文稿整理成可以拆分、复用的内容资料库 |
  126. | [`/dbs-human-dispatch`](skills/dbs-human-dispatch/SKILL.md) | 把任务派给员工或协作者,跟进进度并验收结果 |
  127. | [`/dbs-skill-maker`](skills/dbs-skill-maker/SKILL.md) | 制作新的 Skill,或改进已有的 Skill |
  128. | [`/dbs-install-skill`](skills/dbs-install-skill/SKILL.md) | 把 Skill 安装到多个 Agent,并清理重复的入口 |
  129. | [`/dbs-computer-use`](skills/dbs-computer-use/SKILL.md) | 让 Agent 在电脑上操作网页和桌面 App,尽量在后台进行、不抢鼠标;缺工具时先说明再引导安装,付款、删除、发送前停下等你确认 |
  130. ## 安装详情
  131. 以下命令都在终端运行,不要作为聊天内容发给 Agent
  132. ### Skills CLI
  133. ```bash
  134. npx -y skills add dontbesilent2025/dbskill -g --all
  135. ```
  136. `-g` 表示全局安装,`--all` 表示安装到 Skills CLI 识别的所有 Agent。只想装到一个 Agent 时,删掉 `--all`,按提示选择
  137. ### Claude Code 插件市场
  138. ```bash
  139. claude plugin marketplace add dontbesilent2025/dbskill
  140. claude plugin install dbs@dontbesilent-skills
  141. ```
  142. 插件方式下,命令前面要加 `dbs:`,例如 `/dbs:dbs`、`/dbs:dbs-diagnosis`
  143. 只装一个 Skill 时,安装对应的插件,例如:
  144. ```bash
  145. claude plugin install dbs-diagnosis@dontbesilent-skills
  146. ```
  147. ![Claude Code 插件安装演示](demo.gif)
  148. ### 装好后没看到命令
  149. 先确认安装命令运行成功,并且装到的是你正在用的 Agent。Skills CLI 安装用短命令,例如 `/dbs`;Claude Code 插件用带 `dbs:` 的命令。具体名称以 Agent 里显示的为准
  150. ## 更多用法
  151. ### 直接调用某个 Skill
  152. 在命令后写上问题、材料和你想要的结果:
  153. ```text
  154. /dbs-diagnosis 我做收纳咨询,客单价 3,000 元。最近 10 个咨询里有 6 个说贵,3 个没有回复。请判断下一步先核实什么
  155. ```
  156. ```text
  157. /dbs-title-cover-intro 这是准备拍的短视频稿,请按小红书发布,给我标题、封面文字和开头:粘贴文稿
  158. ```
  159. 提问时附上这些信息,结果会更准确:
  160. - 你手上已有的事实和数字,例如价格、人数、成交情况
  161. - 完整的稿子或材料,不要只给摘要
  162. - 你想要什么结果,例如判断、方案,还是能直接用的文字
  163. 需要读取本地文件、联网或处理视频的 Skill,Agent 还要有相应的权限或工具,具体见各 Skill 的说明
  164. ### 使用视频里的三位编号
  165. 在 dontbesilent 的视频里拿到三位编号后,输入:
  166. ```text
  167. /dbs 123
  168. ```
  169. 把 `123` 换成视频给出的编号。想看当前所有编号,输入 `/dbs 给我所有隐藏级 skill`。编号内容在使用时从 GitHub 读取,Agent 需要能访问 GitHub
  170. ### 跨对话保留结论
  171. 用 `/dbs-save` 保存当前的结论,下次用 `/dbs-restore` 接着处理。存档保存在本机 `~/.dbs/`
  172. ## 仓库资料
  173. 安装 Skill 不会下载这些资料,需要时在仓库里查阅
  174. | 资料 | 用途 |
  175. | --- | --- |
  176. | [dontbesilent 推文集(Markdown)](books/dontbesilent-开源推文集.md) | 搜索、阅读,或交给 AI 分析 |
  177. | [dontbesilent 推文集(PDF)](books/dontbesilent-开源推文集.pdf) | 阅读和保存 |
  178. | [原子库说明](知识库/原子库/README.md) | 数据范围、字段和使用方式 |
  179. | [知识原子数据](知识库/原子库/atoms.jsonl) | 自建检索、分析或 RAG |
  180. | [Skill 知识包](知识库/Skill知识包) | 按 Skill 整理的方法资料 |
  181. ## 更新与帮助
  182. 在 Agent 对话里说:
  183. ```text
  184. 更新 dbskill
  185. ```
  186. 更新会同步官方 dbskill,保留 `~/.dbs/` 里的存档和记录,并自动清理已经下线的旧 Skill。手动清理方法见[新手入门](docs/新手入门.md#怎样更新)。历史改动见[更新记录](https://github.com/dontbesilent2025/dbskill/commits/main)
  187. - [新手入门与 Skill 全目录](docs/新手入门.md)
  188. - [提交问题或建议](https://github.com/dontbesilent2025/dbskill/issues)
  189. - [付费答疑群说明](https://mp.weixin.qq.com/s/RpwNjMo4M_er4GOrfCYt1g)
  190. - 作者:[@dontbesilent](https://x.com/dontbesilent) · [小红书](https://xhslink.com/m/637xuspR4iI) · [抖音](https://v.douyin.com/pRUDhpBqOrc/)
  191. ## 贡献者
  192. `dbs-content-risk-check` 的敏感词检查能力由以下共创者共同完善:
  193. - [@Ronnie2025](https://github.com/Ronnie2025)
  194. - [@非著名投放小沈](https://xhslink.cn/m/4NSBjmZTC1j)
  195. ## 许可证
  196. 本项目版权归 dontbesilent 所有,保留所有权利,完整条款见 [LICENSE](LICENSE)。
  197. - 你可以免费安装和使用 Skill,包括用它做自己的生意、给自己的客户提供服务,也可以在自己的设备上修改后自用。
  198. - 未经书面许可,不得转载、再分发、打包进其他产品、出售或公开发布修改版,也不得用于训练 AI 模型。分享本仓库链接不受限制。
  199. - `books/` 目录只供免费阅读,见 [books/LICENSE](books/LICENSE)。
  200. - 2026-11-02 之前发布的版本,仍按当时的 CC BY-NC 4.0 授权。
  201. 申请授权请发邮件至 openmarshall@gmail.com。
skills/dbs-sync-to-dondon/scripts/sync_material.py · Bundled script · 989 lines · 1 finding marked
  1. #!/usr/bin/env python3
  2. """从本机 Agent 的聊天记录里整理出写「近况」用的素材,并管理同步状态。
  3. 只用标准库,只读聊天记录;collect 不联网,push 经 HTTPS 推给配对过的 bot。素材文件和状态都放在 ~/.dondon-sync/,权限 600。
  4. 子命令:
  5. collect 整理素材:只取上次同步以后(或最近 N 天)的记录,只留用户说的话和每轮的最后回答,
  6. 先隐去密钥、手机号、证件号、银行卡号、邮箱等,再按字数上限截断,写进素材文件。
  7. copy 从标准输入读近况全文,复制到剪贴板。
  8. mark-synced 记下这次同步的时间,并删掉素材文件。用户确认发出后再运行。
  9. status 显示上次同步时间和能找到的聊天记录位置。
  10. push 把 collect 找出的文档隐去敏感信息后推到 bot 的知识库,近况(--recent,标准输入)直接写进 bot。
  11. 需要先用 pair 配对;没配对的电脑只能用 copy。
  12. skills 从 bot 取它装着的技能列表,写机会清单时只能从这里选。
  13. pair <码> 用 bot 给的 6 位配对码换同步钥匙(客户的正常用法);之后 push 走 HTTPS,只认 Skill 自带的证书。
  14. schedule 自动同步:on [--time HH:MM] 每天定时同步一次(macOS);off 关掉;decline 记下用户不要;status 查看。
  15. auto-run 定时任务实际运行的命令:整理素材 → 请本机 Agent(不开任何工具)写近况和机会清单 → 推送 → 记同步时间。
  16. 不同步的内容:API 密钥、令牌、密码、私钥、助记词。文档里只要出现一处,整份文档不传;文件名像存这些东西的文档也不传。
  17. 手机号、邮箱、证件号、银行卡号在聊天素材、文档、近况和机会清单里一律先换成「〔已隐去〕」。
  18. 聊天记录来源:Claude Code、Codex、WorkBuddy、Grok CLI。豆包的对话存在云端,本机读不到。
  19. """
  20. import argparse
  21. import glob
  22. import json
  23. import os
  24. import re
  25. import shutil
  26. import subprocess
  27. import sys
  28. from datetime import datetime, timedelta, timezone
  29. from urllib.parse import unquote
  30. import socket
  31. import ssl
  32. import time
  33. import urllib.error
  34. import urllib.request
  35. STATE_DIR = os.path.expanduser("~/.dondon-sync")
  36. STATE_FILE = os.path.join(STATE_DIR, "state.json")
  37. MATERIAL_FILE = os.path.join(STATE_DIR, "material.md")
  38. CLAUDE_GLOB = os.path.expanduser("~/.claude/projects/*/*.jsonl")
  39. CODEX_GLOB = os.path.expanduser("~/.codex/sessions/**/*.jsonl")
  40. WORKBUDDY_GLOB = os.path.expanduser("~/.workbuddy/projects/*/*.jsonl")
  41. GROK_GLOB = os.path.expanduser("~/.grok/sessions/*/*/chat_history.jsonl")
  42. CONFIG_FILE = os.path.join(STATE_DIR, "config.json")
  43. FILES_LIST = os.path.join(STATE_DIR, "files.json")
  44. STAGE_DIR = os.path.join(STATE_DIR, "stage")
  45. REMOTE_DIR_NAME = "近期工作文件"
  46. OWNER_LINE = "这是客户本人的资料,不是别人的。客户问到自己(我是谁、我做什么、我说过什么)和自己的生意、内容、产品时,先在这里找。"
  47. SYNC_MARK = "【近况同步】"
  48. USER_MSG_LIMIT = 500 # 每条用户消息最多保留的字数
  49. ANSWER_LIMIT = 600 # 每轮最后回答最多保留的字数
  50. DEFAULT_MAX_CHARS = 30000 # 素材总字数上限
  51. SESSION_MIN_BUDGET = 1000 # 每个会话至少分到的字数
  52. DEFAULT_DAYS = 7 # 写近况看最近几天的聊天:一周才看得出主线和卡点
  53. FILE_DAYS = 14 # 文档取最近几天用到的:每次整批替换,所以每批都要带够两周
  54. MAX_DAYS = 30
  55. REDACT = "〔已隐去〕"
  56. REDACT_PATTERNS = [
  57. re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----.*?-----END [A-Z ]*PRIVATE KEY-----", re.S),
  58. re.compile(r"\b(?:sk|pk|rk)-[A-Za-z0-9_\-]{12,}"),
  59. re.compile(r"\b(?:ddb|ghp|gho|ghs|github_pat|xox[abpr]|glpat|AKIA|ASIA)[_\-]?[A-Za-z0-9_\-]{10,}"),
  60. re.compile(r"\beyJ[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{5,}"), # JWT
  61. re.compile(r"(?i)\b(?:bearer|token|api[_\-]?key|secret|password|passwd|pwd|密码|口令|密钥)\s*[:=:]\s*\S+"),
  62. re.compile(r"\b[A-Fa-f0-9]{32,}\b"),
  63. re.compile(r"\b[A-Za-z0-9+/]{40,}={0,2}"),
  64. re.compile(r"[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}"),
  65. re.compile(r"(?<!\d)\d{17}[\dXx](?!\d)"), # 身份证
  66. re.compile(r"(?<!\d)\d{16,19}(?!\d)"), # 银行卡
  67. re.compile(r"(?<!\d)(?:\+?86[\- ]?)?1[3-9]\d{9}(?!\d)"), # 手机号
  68. ]
  69. # 核心秘密:文档里只要出现一处,整份不传(隐去还不够:留着上下文也可能被拼回去)。这些东西对 bot 帮用户做事没有用处。
  70. SECRET_VALUE = r"[\"'`]?[A-Za-z0-9_\-+/=.]{12,}"
  71. SECRET_PATTERNS = [
  72. re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----"),
  73. re.compile(r"\b(?:sk|pk|rk)-[A-Za-z0-9_\-]{16,}"),
  74. re.compile(r"\b(?:ghp|gho|ghs|github_pat|xox[abpr]|glpat|AKIA|ASIA|ddb|dds)[_\-]?[A-Za-z0-9_\-]{12,}"),
  75. re.compile(r"\beyJ[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{5,}"), # JWT
  76. re.compile(r"(?i)\b(?:api[_\-]?key|secret[_\-]?key|access[_\-]?key|client[_\-]?secret|app[_\-]?secret|auth[_\-]?token|"
  77. r"access[_\-]?token|password|passwd|bearer)\s*[:=:]?\s*" + SECRET_VALUE),
  78. re.compile(r"(?:密钥|密码|口令|私钥|助记词|令牌)\s*[:=:]\s*" + SECRET_VALUE),
  79. ]
  80. SECRET_NAME_RE = re.compile(r"(?i)(api[_\- ]?keys?|secrets?|passw(?:or)?ds?|credentials?|\.env\b|密钥|密码|口令|私钥|凭证|助记词)")
  81. def secret_hit(text):
  82. return any(p.search(text) for p in SECRET_PATTERNS)
  83. # 宿主自动注入、不是用户本人说的话
  84. INJECTED_PREFIXES = (
  85. "<", "# AGENTS.md instructions", "Caveat:", "[Request interrupted", "This session is being continued",
  86. "Base directory for this skill", "[SYSTEM NOTIFICATION",
  87. )
  88. def redact(text):
  89. for p in REDACT_PATTERNS:
  90. text = p.sub(REDACT, text)
  91. return text
  92. def clip(text, limit):
  93. text = re.sub(r"```.*?```", "〔代码略〕", text, flags=re.S)
  94. text = re.sub(r"(?m)^#{1,6}\s+", "", text) # 去掉标题符号,免得和会话标题混在一起
  95. text = re.sub(r"[ \t]+", " ", text)
  96. text = re.sub(r"\n{3,}", "\n\n", text).strip()
  97. return text if len(text) <= limit else text[:limit] + "……"
  98. def parse_time(s):
  99. if not s:
  100. return None
  101. try:
  102. return datetime.fromisoformat(str(s).replace("Z", "+00:00"))
  103. except ValueError:
  104. return None
  105. def is_user_words(text):
  106. t = text.lstrip()
  107. return bool(t) and not t.startswith(INJECTED_PREFIXES) and SYNC_MARK not in t
  108. def project_name(cwd):
  109. return os.path.basename(cwd.rstrip("/")) if cwd else "未知目录"
  110. def read_jsonl(path):
  111. try:
  112. with open(path, encoding="utf-8", errors="replace") as f:
  113. for line in f:
  114. try:
  115. yield json.loads(line)
  116. except ValueError:
  117. continue
  118. except OSError:
  119. return
  120. def claude_sessions(since, refs=None):
  121. """Claude Code:~/.claude/projects/<目录>/<会话>.jsonl。子 Agent 的记录在 subagents/ 下,不读。"""
  122. for path in glob.glob(CLAUDE_GLOB):
  123. if datetime.fromtimestamp(os.path.getmtime(path), timezone.utc) < since:
  124. continue
  125. title, cwd, turns, last_answer = None, None, [], None
  126. for o in read_jsonl(path):
  127. kind = o.get("type")
  128. if kind == "custom-title":
  129. title = o.get("customTitle") or title
  130. continue
  131. if kind not in ("user", "assistant") or o.get("isSidechain") or o.get("isMeta"):
  132. continue
  133. ts = parse_time(o.get("timestamp"))
  134. if not ts or ts < since:
  135. continue
  136. cwd = o.get("cwd") or cwd
  137. content = (o.get("message") or {}).get("content")
  138. if kind == "user":
  139. if isinstance(content, str):
  140. texts = [content]
  141. elif isinstance(content, list):
  142. texts = [b.get("text", "") for b in content if isinstance(b, dict) and b.get("type") == "text"]
  143. else:
  144. texts = []
  145. texts = [t for t in texts if is_user_words(t)]
  146. if texts:
  147. note_refs(refs, texts, ts, "Claude Code", title)
  148. if turns and last_answer:
  149. turns[-1]["answer"] = last_answer
  150. last_answer = None
  151. turns.append({"time": ts, "user": "\n".join(texts), "answer": None})
  152. elif isinstance(content, list):
  153. note_refs(refs, [b.get("input") for b in content if isinstance(b, dict) and b.get("type") == "tool_use"],
  154. ts, "Claude Code", title)
  155. texts = [b.get("text", "") for b in content if isinstance(b, dict) and b.get("type") == "text"]
  156. if any(t.strip() for t in texts):
  157. last_answer = "\n".join(texts)
  158. if turns and last_answer:
  159. turns[-1]["answer"] = last_answer
  160. if turns:
  161. yield {"source": "Claude Code", "title": title, "project": project_name(cwd), "turns": turns}
  162. def codex_sessions(since, refs=None):
  163. """Codex:~/.codex/sessions/年/月/日/rollout-*.jsonl。parent_thread_id 不为空的是子线程,不读。"""
  164. for path in glob.glob(CODEX_GLOB, recursive=True):
  165. if datetime.fromtimestamp(os.path.getmtime(path), timezone.utc) < since:
  166. continue
  167. cwd, turns, last_answer, child = None, [], None, False
  168. for o in read_jsonl(path):
  169. p = o.get("payload") or {}
  170. if o.get("type") == "session_meta":
  171. child = bool(p.get("parent_thread_id"))
  172. cwd = p.get("cwd")
  173. continue
  174. if o.get("type") != "response_item" or p.get("type") not in ("message", "function_call", "custom_tool_call"):
  175. continue
  176. ts = parse_time(o.get("timestamp")) or datetime.fromtimestamp(os.path.getmtime(path), timezone.utc)
  177. if ts < since:
  178. continue
  179. if p.get("type") != "message":
  180. if not child:
  181. note_refs(refs, p.get("arguments") or p.get("input"), ts, "Codex", None)
  182. continue
  183. texts = [b.get("text", "") for b in p.get("content") or [] if isinstance(b, dict)]
  184. if p.get("role") == "user":
  185. texts = [t for t in texts if is_user_words(t)]
  186. if texts:
  187. if not child:
  188. note_refs(refs, texts, ts, "Codex", None)
  189. if turns and last_answer:
  190. turns[-1]["answer"] = last_answer
  191. last_answer = None
  192. turns.append({"time": ts, "user": "\n".join(texts), "answer": None})
  193. elif p.get("role") == "assistant" and any(t.strip() for t in texts):
  194. last_answer = "\n".join(texts)
  195. if child:
  196. continue
  197. if turns and last_answer:
  198. turns[-1]["answer"] = last_answer
  199. if turns:
  200. yield {"source": "Codex", "title": None, "project": project_name(cwd), "turns": turns}
  201. def ms_time(v):
  202. try:
  203. return datetime.fromtimestamp(int(v) / 1000, timezone.utc)
  204. except (TypeError, ValueError, OverflowError, OSError):
  205. return None
  206. def block_texts(content):
  207. if isinstance(content, str):
  208. return [content]
  209. if isinstance(content, list):
  210. return [b.get("text", "") for b in content if isinstance(b, dict) and isinstance(b.get("text"), str)]
  211. return []
  212. def workbuddy_sessions(since, refs=None):
  213. """WorkBuddy:~/.workbuddy/projects/<目录>/<会话>.jsonl,条目 type=message(role user/assistant)、function_call。"""
  214. for path in glob.glob(WORKBUDDY_GLOB):
  215. if datetime.fromtimestamp(os.path.getmtime(path), timezone.utc) < since:
  216. continue
  217. title, cwd, turns, last_answer = None, None, [], None
  218. for o in read_jsonl(path):
  219. kind = o.get("type")
  220. if kind == "ai-title":
  221. title = o.get("aiTitle") or title
  222. continue
  223. cwd = o.get("cwd") or cwd
  224. ts = ms_time(o.get("timestamp")) or parse_time(o.get("timestamp"))
  225. if not ts or ts < since:
  226. continue
  227. if kind == "function_call":
  228. note_refs(refs, o.get("arguments"), ts, "WorkBuddy", title)
  229. continue
  230. if kind != "message":
  231. continue
  232. texts = block_texts(o.get("content"))
  233. if o.get("role") == "user":
  234. texts = [t for t in texts if is_user_words(t)]
  235. if texts:
  236. note_refs(refs, texts, ts, "WorkBuddy", title)
  237. if turns and last_answer:
  238. turns[-1]["answer"] = last_answer
  239. last_answer = None
  240. turns.append({"time": ts, "user": "\n".join(texts), "answer": None})
  241. elif o.get("role") == "assistant" and any(t.strip() for t in texts):
  242. last_answer = "\n".join(texts)
  243. if turns and last_answer:
  244. turns[-1]["answer"] = last_answer
  245. if turns:
  246. yield {"source": "WorkBuddy", "title": title, "project": project_name(cwd), "turns": turns}
  247. GROK_QUERY = re.compile(r"<user_query>\s*(.*?)\s*</user_query>", re.S)
  248. def grok_sessions(since, refs=None):
  249. """Grok CLI:~/.grok/sessions/<编码后的目录>/<会话>/chat_history.jsonl,条目 type=user/assistant/tool_result。
  250. 用户的话包在 <user_query> 里,其余是宿主注入的环境说明。条目没有时间,用文件修改时间。"""
  251. for path in glob.glob(GROK_GLOB):
  252. mtime = datetime.fromtimestamp(os.path.getmtime(path), timezone.utc)
  253. if mtime < since:
  254. continue
  255. cwd = unquote(os.path.basename(os.path.dirname(os.path.dirname(path))))
  256. turns, last_answer = [], None
  257. for o in read_jsonl(path):
  258. kind = o.get("type")
  259. if kind == "user":
  260. texts = []
  261. for t in block_texts(o.get("content")):
  262. m = GROK_QUERY.search(t)
  263. if m:
  264. texts.append(m.group(1))
  265. elif is_user_words(t):
  266. texts.append(t)
  267. if texts:
  268. note_refs(refs, texts, mtime, "Grok", None)
  269. if turns and last_answer:
  270. turns[-1]["answer"] = last_answer
  271. last_answer = None
  272. turns.append({"time": mtime, "user": "\n".join(texts), "answer": None})
  273. elif kind == "assistant":
  274. note_refs(refs, {k: v for k, v in o.items() if k != "content"}, mtime, "Grok", None)
  275. texts = block_texts(o.get("content"))
  276. if any(t.strip() for t in texts):
  277. last_answer = "\n".join(texts)
  278. if turns and last_answer:
  279. turns[-1]["answer"] = last_answer
  280. if turns:
  281. yield {"source": "Grok", "title": None, "project": project_name(cwd), "turns": turns}
  282. # ---------------------------------------------------------------- 会话里用到的文件
  283. HOME = os.path.expanduser("~")
  284. ICLOUD = os.path.join(HOME, "Library", "Mobile Documents", "com~apple~CloudDocs")
  285. PATH_RE = re.compile(r"(?:/Users/|~/)[^\n\r\t\"'`<>|*?\\]*?\.(?:md|markdown|txt)(?![A-Za-z0-9_])")
  286. FILE_EXTS = (".md", ".markdown", ".txt")
  287. # 不同步的位置:Agent 自己的配置和记录、本工具、临时目录、客户资料暂存、私密目录
  288. SKIP_PREFIXES = [os.path.join(HOME, d) for d in (
  289. ".claude", ".codex", ".workbuddy", ".grok", ".agents", ".gemini", ".cursor", ".dondon-sync",
  290. "dondon-kb-staging", "Downloads",
  291. )]
  292. SKIP_PARTS = {".git", "node_modules", "private", ".private", "evals", ".obsidian", ".trash", "build", "dist",
  293. "skills", "vendor", "__pycache__"}
  294. SKIP_NAMES = {"SKILL.md", "AGENTS.md", "CLAUDE.md", "CODEBUDDY.md", "GEMINI.md", "MEMORY.md", "SOURCE_OF_TRUTH.md"}
  295. MAX_FILE_BYTES = 1024 * 1024 # 单个文件超过 1 MB 不传
  296. MAX_TOTAL_BYTES = 20 * 1024 * 1024 # 一次最多 20 MB
  297. MAX_FILES = 400
  298. def walk_strings(v, depth=0):
  299. if depth > 12:
  300. return
  301. if isinstance(v, str):
  302. yield v
  303. elif isinstance(v, dict):
  304. for x in v.values():
  305. yield from walk_strings(x, depth + 1)
  306. elif isinstance(v, list):
  307. for x in v:
  308. yield from walk_strings(x, depth + 1)
  309. def note_refs(refs, value, ts, source, title):
  310. """在工具调用参数和用户的话里找本机文档路径,记下次数、最近时间和来自哪个会话。"""
  311. if refs is None or value is None:
  312. return
  313. if isinstance(value, str):
  314. try:
  315. value = json.loads(value)
  316. except ValueError:
  317. pass
  318. for s in walk_strings(value):
  319. if "/Users/" not in s and "~/" not in s:
  320. continue
  321. for m in PATH_RE.finditer(s):
  322. p = os.path.normpath(os.path.expanduser(m.group(0)))
  323. r = refs.setdefault(p, {"count": 0, "last": ts, "from": set()})
  324. r["count"] += 1
  325. if ts > r["last"]:
  326. r["last"] = ts
  327. r["from"].add(f"{source}|{title}" if title else source)
  328. def skip_reason(p):
  329. if not p.startswith(HOME + os.sep) or not p.lower().endswith(FILE_EXTS):
  330. return "不在本人目录或不是文档"
  331. if any(p == d or p.startswith(d + os.sep) for d in SKIP_PREFIXES):
  332. return "Agent 配置或暂存目录"
  333. if p.startswith(os.path.join(HOME, "Library") + os.sep) and not p.startswith(ICLOUD + os.sep):
  334. return "系统目录"
  335. parts = os.path.relpath(p, HOME).split(os.sep)
  336. if any(x in SKIP_PARTS or (x.startswith(".") and x not in (".",)) for x in parts[:-1]):
  337. return "私密、隐藏或生成目录"
  338. if parts[-1] in SKIP_NAMES or parts[-1].startswith("."):
  339. return "Agent 规则文件"
  340. if SECRET_NAME_RE.search(parts[-1]):
  341. return SECRET_REASON
  342. return None
  343. SECRET_REASON = "像是存密钥、密码的文档,整份不传"
  344. def remote_rel(p):
  345. """本机路径 → 同步目录里的相对路径:去掉主目录、iCloud 前缀和「claude code/」。"""
  346. rel = os.path.relpath(p, ICLOUD) if p.startswith(ICLOUD + os.sep) else os.path.relpath(p, HOME)
  347. if rel.startswith("claude code" + os.sep):
  348. rel = rel[len("claude code" + os.sep):]
  349. return rel
  350. def pick_files(refs):
  351. """按最近用到的时间排序,过滤后在数量和总量上限内取文件。含核心秘密的整份不取,名字记进 held。"""
  352. picked, skipped, total, held = [], {}, 0, []
  353. for p, r in sorted(refs.items(), key=lambda kv: (kv[1]["last"], kv[1]["count"]), reverse=True):
  354. why = skip_reason(p)
  355. if not why and not os.path.isfile(p):
  356. why = "文件已不在"
  357. if not why:
  358. size = os.path.getsize(p)
  359. if size > MAX_FILE_BYTES:
  360. why = "单个文件超过 1 MB"
  361. elif total + size > MAX_TOTAL_BYTES or len(picked) >= MAX_FILES:
  362. why = "超出 20 MB 或 400 个文件的上限"
  363. else:
  364. try:
  365. with open(p, encoding="utf-8") as fh:
  366. if secret_hit(fh.read()):
  367. why = SECRET_REASON
  368. except (OSError, UnicodeDecodeError):
  369. why = "读不出来"
  370. if why == SECRET_REASON:
  371. held.append(remote_rel(p))
  372. if why:
  373. skipped[why] = skipped.get(why, 0) + 1
  374. continue
  375. total += size
  376. picked.append({"path": p, "rel": remote_rel(p), "size": size, "count": r["count"],
  377. "last": r["last"].isoformat(), "from": sorted(r["from"])[:3]})
  378. return picked, skipped, total, held
  379. def load_state():
  380. try:
  381. with open(STATE_FILE, encoding="utf-8") as f:
  382. return json.load(f)
  383. except (OSError, ValueError):
  384. return {}
  385. def save_private(path, text):
  386. os.makedirs(STATE_DIR, mode=0o700, exist_ok=True)
  387. fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
  388. with os.fdopen(fd, "w", encoding="utf-8") as f:
  389. f.write(text)
  390. def local(ts):
  391. return ts.astimezone().strftime("%m-%d %H:%M")
  392. def render_turn(t, answer_limit):
  393. out = f"- 用户({local(t['time'])}):{redact(clip(t['user'], USER_MSG_LIMIT))}"
  394. if t["answer"]:
  395. out += f"\n 回答:{redact(clip(t['answer'], answer_limit))}"
  396. return out
  397. def render_session(s, budget):
  398. """每个会话一份篇幅:第一轮(交代任务)必留,其余从最近一轮往前放,放不下的中间轮次略去。"""
  399. turns = s["turns"]
  400. first, last = turns[0]["time"], turns[-1]["time"]
  401. head = f"## {'【上次同步以后有新进展】' if s.get('new') and s.get('mark_new') else ''}{s['source']}|{s['project']}"
  402. if s["title"]:
  403. head += f"|{s['title']}"
  404. head += f"\n时间:{local(first)} 至 {local(last)},共 {len(turns)} 轮\n"
  405. answer_limit = ANSWER_LIMIT if len(turns) <= 3 else ANSWER_LIMIT // 2
  406. opening = render_turn(turns[0], answer_limit)
  407. used = len(head) + len(opening)
  408. recent = []
  409. for t in reversed(turns[1:]):
  410. line = render_turn(t, answer_limit)
  411. if used + len(line) > budget:
  412. break
  413. recent.append(line)
  414. used += len(line)
  415. skipped = len(turns) - 1 - len(recent)
  416. body = [opening] + ([f"- ……(中间 {skipped} 轮略去)"] if skipped else []) + list(reversed(recent))
  417. return head + "\n" + "\n".join(body) + "\n"
  418. def cmd_collect(args):
  419. now = datetime.now(timezone.utc)
  420. state = load_state()
  421. # 范围固定,不从上次同步算起:聊天看最近 7 天写近况,文档取最近 14 天(整批替换,少了就会把前几天的清掉)。
  422. # 上次同步的时间只用来标出哪些会话有新进展、自动同步时判断有没有新东西。
  423. days = min(args.days, MAX_DAYS) if args.days else DEFAULT_DAYS
  424. since = now - timedelta(days=days)
  425. files_since = now - timedelta(days=max(days, FILE_DAYS))
  426. last_sync = parse_time(state["last_sync"]) if state.get("last_sync") else None
  427. sessions, refs = [], {}
  428. readers = {"claude": claude_sessions, "codex": codex_sessions, "workbuddy": workbuddy_sessions, "grok": grok_sessions}
  429. for name in args.sources:
  430. if name in readers:
  431. sessions += list(readers[name](files_since, refs))
  432. # 写近况只用最近 days 天的轮次
  433. for x in sessions:
  434. x["turns"] = [t for t in x["turns"] if t["time"] >= since]
  435. sessions = [x for x in sessions if x["turns"]]
  436. for x in sessions:
  437. x["new"] = last_sync is None or x["turns"][-1]["time"] > last_sync
  438. if args.exclude:
  439. refs = {p: r for p, r in refs.items() if not any(x in p for x in args.exclude)}
  440. files, skipped, total, held = pick_files(refs)
  441. save_private(FILES_LIST, json.dumps({"since": files_since.isoformat(), "files": files, "held_back": held}, ensure_ascii=False))
  442. if args.exclude:
  443. sessions = [s for s in sessions if not any(x in s["project"] for x in args.exclude)]
  444. # 最近的会话优先;超出字数上限时丢掉最旧的会话
  445. sessions.sort(key=lambda s: s["turns"][-1]["time"], reverse=True)
  446. # 分出去的旁支会话会带上主会话的历史,同一轮只留第一次出现的那份
  447. seen, unique = set(), []
  448. for s in sessions:
  449. turns = []
  450. for t in s["turns"]:
  451. key = (t["time"].replace(microsecond=0), t["user"][:80])
  452. if key not in seen:
  453. seen.add(key)
  454. turns.append(t)
  455. if turns:
  456. s["turns"] = turns
  457. unique.append(s)
  458. sessions = unique
  459. # 每个会话分到同样的篇幅(至少 SESSION_MIN_BUDGET),总量超了就丢掉最旧的会话
  460. for x in sessions:
  461. x["mark_new"] = last_sync is not None
  462. budget = max(SESSION_MIN_BUDGET, args.max_chars // max(len(sessions), 1))
  463. blocks, used, dropped = [], 0, 0
  464. for s in sessions:
  465. block = render_session(s, budget)
  466. if used + len(block) > args.max_chars:
  467. dropped += 1
  468. continue
  469. blocks.append(block)
  470. used += len(block)
  471. sources = sorted({s["source"] for s in sessions})
  472. header = [
  473. "# 近况素材(只在本机使用,写完近况后会删除)",
  474. "",
  475. f"范围:{since.astimezone().strftime('%Y-%m-%d %H:%M')} 至 {now.astimezone().strftime('%Y-%m-%d %H:%M')}(最近 {days} 天)"
  476. + (f";上次同步 {local(last_sync)},标「上次同步以后有新进展」的会话写近况时放在前面" if last_sync else ""),
  477. f"来源:{'、'.join(sources) if sources else '无'};会话 {len(sessions)} 个,收入 {len(blocks)} 个,"
  478. f"因字数上限略去较旧的 {dropped} 个",
  479. "已隐去:密钥、令牌、密码、长串编码、邮箱、手机号、证件号、银行卡号;代码块已略去。"
  480. "近况和机会清单里不写任何密钥、密码、账号。",
  481. "",
  482. ]
  483. by_proj = {}
  484. for f in files:
  485. top = f["rel"].split(os.sep)[0] if os.sep in f["rel"] else "其他"
  486. by_proj[top] = by_proj.get(top, 0) + 1
  487. flist = ["", f"# 最近 {max(days, FILE_DAYS)} 天用到的文档({len(files)} 个,共 {total / 1024 / 1024:.1f} MB,确认后会同步给 bot)", ""]
  488. flist += [f"- {f['rel']}({local(datetime.fromisoformat(f['last']))},用到 {f['count']} 次)" for f in files[:60]]
  489. if len(files) > 60:
  490. flist.append(f"- ……另外 {len(files) - 60} 个")
  491. save_private(MATERIAL_FILE, "\n".join(header) + "\n".join(blocks) + "\n".join(flist) + "\n")
  492. print(json.dumps({
  493. "material": MATERIAL_FILE,
  494. "since": since.astimezone().strftime("%Y-%m-%d"),
  495. "files_since": files_since.astimezone().strftime("%Y-%m-%d"),
  496. "sessions_new_since_last_sync": sum(1 for x in sessions if x["new"]),
  497. "until": now.astimezone().strftime("%Y-%m-%d"),
  498. "sources": sources,
  499. "sessions_found": len(sessions),
  500. "sessions_included": len(blocks),
  501. "sessions_dropped": dropped,
  502. "chars": used,
  503. "files": len(files),
  504. "files_mb": round(total / 1024 / 1024, 2),
  505. "files_by_folder": dict(sorted(by_proj.items(), key=lambda kv: -kv[1])[:10]),
  506. "files_skipped": skipped,
  507. "held_back_secret_files": held[:20],
  508. }, ensure_ascii=False))
  509. return {"sessions": len(blocks), "new": sum(1 for x in sessions if x["new"]), "files": len(files),
  510. "since": since, "until": now, "sources": sources}
  511. def cmd_copy(_args):
  512. text = sys.stdin.read().strip()
  513. if not text.startswith(SYNC_MARK):
  514. sys.exit(f"近况第一行必须是「{SYNC_MARK}」,没有复制。")
  515. for cmd in (["pbcopy"], ["clip"], ["wl-copy"], ["xclip", "-selection", "clipboard"], ["xsel", "--clipboard", "--input"]):
  516. if shutil.which(cmd[0]):
  517. # pbcopy 按系统区域设置解码,没设 UTF-8 时中文会变成乱码
  518. env = dict(os.environ, LANG="en_US.UTF-8", LC_ALL="en_US.UTF-8")
  519. subprocess.run(cmd, input=text.encode("utf-8"), check=True, env=env)
  520. print(f"已复制到剪贴板({len(text)} 字)。")
  521. return
  522. sys.exit("这台电脑上没找到剪贴板命令,请手动复制近况全文。")
  523. def cmd_mark_synced(_args):
  524. state = load_state()
  525. state["last_sync"] = datetime.now(timezone.utc).isoformat()
  526. save_private(STATE_FILE, json.dumps(state, ensure_ascii=False))
  527. for f in (MATERIAL_FILE, FILES_LIST):
  528. if os.path.exists(f):
  529. os.remove(f)
  530. print(f"已记下同步时间 {datetime.now().strftime('%Y-%m-%d %H:%M')},素材和文件清单已删除。")
  531. DEFAULT_SERVER = "https://101.201.141.217:8443" # dondon 的同步入口(只开 /sync/*)
    • Note: Names a raw IP address or throwaway host in a file that sets a program to start on its own
    • Line 605 on GitHub
  532. CA_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "dondon-ca.pem") # 只认这张证书
  533. KEY_RE = re.compile(r"dds_[A-Za-z0-9_-]{20,}")
  534. SERVER_RE = re.compile(r"https://[0-9A-Za-z.-]+(?::\d{2,5})?|http://127\.0\.0\.1:\d{2,5}")
  535. def load_config():
  536. try:
  537. with open(CONFIG_FILE, encoding="utf-8") as f:
  538. cfg = json.load(f)
  539. except (OSError, ValueError):
  540. return None
  541. if cfg.get("key"):
  542. if not KEY_RE.fullmatch(str(cfg["key"])) or not SERVER_RE.fullmatch(str(cfg.get("server", ""))):
  543. sys.exit(f"{CONFIG_FILE} 里的同步钥匙或服务器地址不合规,请对 bot 说「绑定电脑」重新配对。")
  544. return cfg
  545. return None # 没有同步钥匙就当没配对
  546. def api(cfg, method, path, body=None, key=None, timeout=60):
  547. """调同步入口:https 只认 Skill 自带的 dondon-ca.pem;http 只允许 127.0.0.1(本机测试用)"""
  548. server = cfg["server"]
  549. ctx = None
  550. if server.startswith("https://"):
  551. if not os.path.isfile(CA_FILE):
  552. sys.exit("Skill 里缺少 dondon-ca.pem,没法安全连接,请更新这个 Skill。")
  553. ctx = ssl.create_default_context(cafile=CA_FILE)
  554. data = json.dumps(body, ensure_ascii=False).encode("utf-8") if body is not None else None
  555. headers = {"content-type": "application/json"}
  556. if key:
  557. headers["authorization"] = f"Bearer {key}"
  558. req = urllib.request.Request(server + path, data=data, method=method, headers=headers)
  559. # 直连,不走本机的网络代理:代理会替服务器「接通」端口,真正连不上时只剩一句看不懂的握手失败
  560. opener = urllib.request.build_opener(urllib.request.ProxyHandler({}), urllib.request.HTTPSHandler(context=ctx))
  561. try:
  562. with opener.open(req, timeout=timeout) as r:
  563. return r.status, json.loads(r.read().decode("utf-8") or "{}")
  564. except urllib.error.HTTPError as e:
  565. try:
  566. return e.code, json.loads(e.read().decode("utf-8") or "{}")
  567. except ValueError:
  568. return e.code, {}
  569. except (urllib.error.URLError, OSError, ValueError) as e:
  570. sys.exit(f"连不上同步服务({getattr(e, 'reason', e)})。多半是同步服务的端口还没对外开放,或者这台电脑的网络"
  571. f"(公司网络、代理软件的全局或 TUN 模式)拦住了 {server.split('://')[-1]};"
  572. "换个网络或把这个地址设成直连再试。一直不行就告诉 dondon 的服务方。")
  573. def err_msg(j):
  574. return ((j or {}).get("error") or {}).get("message") or "未知原因"
  575. def cmd_pair(args):
  576. code = re.sub(r"\D", "", args.code or "")
  577. if len(code) != 6:
  578. sys.exit("配对码是 6 位数字。请在微信或飞书里对 dondon 说「绑定电脑」拿一个。")
  579. server = args.server or DEFAULT_SERVER
  580. if not SERVER_RE.fullmatch(server):
  581. sys.exit("服务器地址不合规。")
  582. st, j = api({"server": server}, "POST", "/sync/claim", {"code": code, "device": socket.gethostname()[:40]})
  583. if st != 200 or not KEY_RE.fullmatch(str(j.get("key", ""))):
  584. sys.exit(f"配对没成功:{err_msg(j)}")
  585. save_private(CONFIG_FILE, json.dumps({"server": server, "key": j["key"], "customer": j.get("customer", "")}, ensure_ascii=False))
  586. print(json.dumps({"paired": True, "customer": j.get("customer", ""), "server": server}, ensure_ascii=False))
  587. def stage_files(files):
  588. """把文档隐去敏感信息后放进暂存目录,并写 INDEX.md。原文件不动。"""
  589. shutil.rmtree(STAGE_DIR, ignore_errors=True)
  590. dest = os.path.join(STAGE_DIR, REMOTE_DIR_NAME)
  591. os.makedirs(dest, mode=0o700)
  592. rows, hidden, unreadable = [], 0, 0
  593. for f in files:
  594. try:
  595. with open(f["path"], encoding="utf-8") as fh:
  596. text = fh.read()
  597. except (OSError, UnicodeDecodeError):
  598. unreadable += 1
  599. continue
  600. if secret_hit(text): # 整理之后才写进密钥的,照样整份不传
  601. unreadable += 1
  602. continue
  603. clean = redact(text)
  604. if clean != text:
  605. hidden += 1
  606. out = os.path.join(dest, f["rel"])
  607. os.makedirs(os.path.dirname(out), exist_ok=True)
  608. with open(out, "w", encoding="utf-8") as fh:
  609. fh.write(clean)
  610. rows.append(f)
  611. by_top = {}
  612. for f in rows:
  613. by_top.setdefault(f["rel"].split(os.sep)[0] if os.sep in f["rel"] else "其他", []).append(f)
  614. lines = [
  615. f"# {REMOTE_DIR_NAME}",
  616. "",
  617. OWNER_LINE,
  618. "",
  619. f"由客户本机的「同步给 dondon」按最近各个 Agent 聊天里读过、写过的文档整理,同步时间 "
  620. f"{datetime.now().strftime('%Y-%m-%d %H:%M')}。每次同步整目录替换;这里没有的文件说明最近没再用到。"
  621. "文件里出现「〔已隐去〕」的地方是本机先隐去的密钥、手机号等。",
  622. "",
  623. ]
  624. for top in sorted(by_top, key=lambda t: -len(by_top[t])):
  625. lines += [f"## {top}({len(by_top[top])} 个)", ""]
  626. for f in sorted(by_top[top], key=lambda x: x["last"], reverse=True):
  627. lines.append(f"- `{f['rel']}`:最近用到 {local(datetime.fromisoformat(f['last']))},"
  628. f"{f['count']} 次,来自 {'、'.join(f['from'])}")
  629. lines.append("")
  630. with open(os.path.join(dest, "INDEX.md"), "w", encoding="utf-8") as fh:
  631. fh.write("\n".join(lines))
  632. return dest, len(rows), hidden, unreadable
  633. HISTORY_DIR = os.path.join(STATE_DIR, "history")
  634. HISTORY_KEEP = 30
  635. def read_opps(args):
  636. if not getattr(args, "opps_file", None):
  637. return ""
  638. with open(args.opps_file, encoding="utf-8") as fh:
  639. return redact(fh.read().strip())
  640. def save_history(recent, opps, files, result, material=""):
  641. """每次发出去的近况、机会清单、文档名(自动同步时还有上传的会话素材)在本机留一份,最多留 HISTORY_KEEP 次,用户随时可以翻看。"""
  642. os.makedirs(HISTORY_DIR, mode=0o700, exist_ok=True)
  643. name = datetime.now().strftime("%Y%m%d-%H%M%S") + ".md"
  644. lines = [f"# 同步记录 {datetime.now().strftime('%Y-%m-%d %H:%M')}", "",
  645. f"结果:{json.dumps(result, ensure_ascii=False)}", "", recent or "(这次没有近况)", "", opps or "(这次没有机会清单)",
  646. "", f"## 发出的文档({len(files)} 个,内容里的手机号等已隐去)", ""]
  647. lines += [f"- {f['rel']}" for f in files]
  648. if material:
  649. lines += ["", "## 上传的会话素材(自动同步时由服务器据此写近况,写完即丢弃)", "", material]
  650. save_private(os.path.join(HISTORY_DIR, name), "\n".join(lines) + "\n")
  651. old = sorted(x for x in os.listdir(HISTORY_DIR) if x.endswith(".md"))
  652. for x in old[:-HISTORY_KEEP]:
  653. os.remove(os.path.join(HISTORY_DIR, x))
  654. def push_key(cfg, args, recent, files, material="", rules=""):
  655. """上传文档和近况、机会清单;自动同步时不带近况,改交会话素材和写法规则,由服务器写近况和机会清单。"""
  656. dest, n, hidden, unreadable = stage_files(files)
  657. up = []
  658. for dp, _, fns in os.walk(dest):
  659. for fn in fns:
  660. full = os.path.join(dp, fn)
  661. with open(full, encoding="utf-8") as fh:
  662. up.append({"path": os.path.relpath(full, dest), "text": fh.read()})
  663. if material:
  664. opps = ""
  665. body = {"files": up, "material": material, "rules": rules}
  666. else:
  667. opps = read_opps(args)
  668. body = {"files": up, "recent": recent, "opps": opps}
  669. st, j = api(cfg, "POST", "/sync/upload", body, key=cfg["key"], timeout=420 if material else 180) # 服务器写近况要一两分钟
  670. shutil.rmtree(STAGE_DIR, ignore_errors=True)
  671. if st != 200:
  672. sys.exit(f"上传没成功:{err_msg(j)}")
  673. if material:
  674. recent, opps = j.get("recent") or "", j.get("opps") or ""
  675. if not recent.startswith(SYNC_MARK):
  676. sys.exit("同步服务还不支持替你写近况(服务方还没升级),这次没发。")
  677. result = {"uploaded_files": n, "redacted_files": hidden, "unreadable_skipped": unreadable}
  678. for _ in range(45): # 服务器每 15 秒处理一次,最多等 90 秒
  679. time.sleep(2)
  680. st, r = api(cfg, "GET", "/sync/result", key=cfg["key"])
  681. if st == 200 and r.get("status") == "done":
  682. result.update({k: r[k] for k in ("ok", "files", "recent", "opps", "message") if k in r})
  683. break
  684. else:
  685. result["note"] = "已经上传,bot 那边还在处理,几分钟内会收到。"
  686. save_history(recent, opps, files, result, material)
  687. print(json.dumps(result, ensure_ascii=False))
  688. if result.get("ok") is False:
  689. sys.exit(1)
  690. def cmd_push(args):
  691. cfg = load_config()
  692. if not cfg:
  693. sys.exit("这台电脑还没和 dondon 配对。请在微信或飞书里对 dondon 说「绑定电脑」,拿到配对码后运行 pair <配对码>。")
  694. recent = redact(sys.stdin.read().strip()) if args.recent else ""
  695. if args.recent and not recent.startswith(SYNC_MARK):
  696. sys.exit(f"近况第一行必须是「{SYNC_MARK}」,没有推送。")
  697. try:
  698. with open(FILES_LIST, encoding="utf-8") as f:
  699. files = json.load(f)["files"]
  700. except (OSError, ValueError, KeyError):
  701. sys.exit("没有文件清单,先运行 collect。")
  702. return push_key(cfg, args, recent, files)
  703. def fetch_skills():
  704. """从 bot 取它装着的技能列表(中文名(英文名)),写机会清单时只能从这里选。"""
  705. cfg = load_config()
  706. if not cfg:
  707. sys.exit("这台电脑还没和 dondon 配对,取不到 bot 的技能列表;机会清单可以不写。")
  708. st, j = api(cfg, "GET", "/sync/skills", key=cfg["key"])
  709. if st != 200:
  710. sys.exit(f"取技能列表失败:{err_msg(j)}")
  711. skills = j.get("skills") or {}
  712. if not skills:
  713. sys.exit("bot 那边还没报上技能列表(几分钟后再试);这次机会清单的技能都写「无」。")
  714. return "\n".join(f"{zh}({en})" for en, zh in skills.items())
  715. def cmd_skills(_args):
  716. print(fetch_skills())
  717. def cmd_status(_args):
  718. state = load_state()
  719. print(json.dumps({
  720. "last_sync": state.get("last_sync"),
  721. "claude_code_logs": len(glob.glob(CLAUDE_GLOB)),
  722. "codex_logs": len(glob.glob(CODEX_GLOB, recursive=True)),
  723. "workbuddy_logs": len(glob.glob(WORKBUDDY_GLOB)),
  724. "grok_logs": len(glob.glob(GROK_GLOB)),
  725. "material_left": os.path.exists(MATERIAL_FILE),
  726. "push_target": {k: v for k, v in (load_config() or {}).items() if k != "key"} or None, # 钥匙不打印
  727. "auto": schedule_info(state),
  728. }, ensure_ascii=False))
  729. # ---------- 自动同步(macOS launchd) ----------
  730. LABEL = "com.dontbesilent.dondon-sync"
  731. PLIST = os.path.expanduser(f"~/Library/LaunchAgents/{LABEL}.plist")
  732. AUTO_LOG = os.path.join(STATE_DIR, "auto.log")
  733. SKILL_FILE = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "SKILL.md")
  734. def schedule_info(state=None):
  735. state = state if state is not None else load_state()
  736. a = state.get("auto") or {}
  737. return {"asked": bool(a.get("asked")), "on": bool(a.get("on")) and os.path.exists(PLIST), "time": a.get("time"),
  738. "last_run": a.get("last_run"), "last_result": a.get("last_result"),
  739. "history_dir": HISTORY_DIR}
  740. def save_auto(**kw):
  741. state = load_state()
  742. state.setdefault("auto", {}).update(kw)
  743. save_private(STATE_FILE, json.dumps(state, ensure_ascii=False))
  744. def launchctl(*a):
  745. return subprocess.run(["launchctl", *a], capture_output=True, text=True)
  746. def cmd_schedule(args):
  747. if args.action == "status":
  748. print(json.dumps(schedule_info(), ensure_ascii=False))
  749. return
  750. if args.action == "decline":
  751. save_auto(asked=True, on=False)
  752. print(json.dumps({"auto": "off", "note": "已记下:只手动同步,以后不再问。想开时说「开启自动同步」。"}, ensure_ascii=False))
  753. return
  754. uid = str(os.getuid())
  755. if args.action == "off":
  756. launchctl("bootout", f"gui/{uid}/{LABEL}")
  757. if os.path.exists(PLIST):
  758. os.remove(PLIST)
  759. save_auto(asked=True, on=False)
  760. print(json.dumps({"auto": "off", "note": "已停止自动同步。"}, ensure_ascii=False))
  761. return
  762. # on
  763. if sys.platform != "darwin":
  764. sys.exit("这台电脑不是 macOS,暂时不支持自动同步;每次手动运行同步就行。")
  765. if not load_config():
  766. sys.exit("这台电脑还没和 dondon 配对,先对 bot 说「绑定电脑」配对,再开自动同步。")
  767. m = re.fullmatch(r"([01]?\d|2[0-3]):([0-5]\d)", args.time or "09:00")
  768. if not m:
  769. sys.exit("时间写成 HH:MM,例如 09:00。")
  770. hour, minute = int(m.group(1)), int(m.group(2))
  771. script = os.path.abspath(__file__)
  772. path_env = "/usr/bin:/bin:/usr/sbin:/sbin"
  773. import plistlib
  774. os.makedirs(os.path.dirname(PLIST), exist_ok=True)
  775. with open(PLIST, "wb") as f:
  776. plistlib.dump({
  777. "Label": LABEL,
  778. "ProgramArguments": [sys.executable, "-I", script, "auto-run"],
  779. "StartCalendarInterval": {"Hour": hour, "Minute": minute}, # 那时在睡眠,醒来后补跑一次
  780. "EnvironmentVariables": {"PATH": path_env, "HOME": HOME, "LANG": "zh_CN.UTF-8"},
  781. "StandardOutPath": AUTO_LOG, "StandardErrorPath": AUTO_LOG,
  782. "ProcessType": "Background", "LowPriorityIO": True,
  783. }, f)
  784. launchctl("bootout", f"gui/{uid}/{LABEL}")
  785. r = launchctl("bootstrap", f"gui/{uid}", PLIST)
  786. if r.returncode:
  787. sys.exit("登记定时任务失败:" + (r.stderr or r.stdout).strip()[-300:])
  788. save_auto(asked=True, on=True, time=f"{hour:02d}:{minute:02d}")
  789. print(json.dumps({"auto": "on", "time": f"每天 {hour:02d}:{minute:02d}",
  790. "history_dir": HISTORY_DIR, "log": AUTO_LOG}, ensure_ascii=False))
  791. def skill_rules():
  792. """从 SKILL.md 取写近况和机会清单的规则(第 2 步、第 2b 步),自动同步时原样交给服务器,按它写近况。"""
  793. try:
  794. text = open(SKILL_FILE, encoding="utf-8").read()
  795. except OSError:
  796. sys.exit("找不到 SKILL.md,自动同步没法按规则写近况。")
  797. a, b = text.find("## 第 2 步"), text.find("## 第 3 步")
  798. if a < 0 or b < a:
  799. sys.exit("SKILL.md 里找不到第 2 步的规则。")
  800. return text[a:b]
  801. def cmd_auto_run(_args):
  802. """定时任务入口。没人看着:任何一步不对就停下记日志,不发半截内容。"""
  803. started = datetime.now()
  804. def done(ok, msg):
  805. save_auto(last_run=started.strftime("%Y-%m-%d %H:%M"), last_result=("成功:" if ok else "没发出:") + msg)
  806. print(f"[{started:%Y-%m-%d %H:%M}] {'成功' if ok else '没发出'}:{msg}", flush=True)
  807. if not ok:
  808. sys.exit(1)
  809. if not load_config():
  810. done(False, "这台电脑还没配对")
  811. cfg = load_config()
  812. ns = argparse.Namespace(days=None, sources=["claude", "codex", "workbuddy", "grok"], exclude=[], max_chars=DEFAULT_MAX_CHARS)
  813. import contextlib
  814. import io
  815. with contextlib.redirect_stdout(io.StringIO()):
  816. info = cmd_collect(ns)
  817. if not info["sessions"] or not info["new"]:
  818. for f in (MATERIAL_FILE, FILES_LIST):
  819. if os.path.exists(f):
  820. os.remove(f)
  821. done(True, "上次同步以后没有新的聊天,这次不发")
  822. material = open(MATERIAL_FILE, encoding="utf-8").read()
  823. try:
  824. with open(FILES_LIST, encoding="utf-8") as f:
  825. files = json.load(f)["files"]
  826. except (OSError, ValueError, KeyError):
  827. done(False, "没有文件清单")
  828. buf = io.StringIO()
  829. try:
  830. with contextlib.redirect_stdout(buf):
  831. push_key(cfg, argparse.Namespace(opps_file=None), "", files, material=redact(material), rules=skill_rules())
  832. pushed = True
  833. except SystemExit as e:
  834. pushed, reason = False, str(e) or buf.getvalue()[-300:]
  835. if not pushed:
  836. done(False, "推送失败:" + reason)
  837. with contextlib.redirect_stdout(io.StringIO()):
  838. cmd_mark_synced(None)
  839. done(True, f"近况和 {info['files']} 个文档已同步(近况由服务器按素材写);发出的内容留在 {HISTORY_DIR}")
  840. def main():
  841. ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
  842. sub = ap.add_subparsers(dest="cmd", required=True)
  843. c = sub.add_parser("collect", help="整理素材")
  844. c.add_argument("--days", type=int, help=f"聊天看最近 N 天(默认 {DEFAULT_DAYS},最多 {MAX_DAYS});文档取 N 天和 {FILE_DAYS} 天里较长的")
  845. c.add_argument("--sources", default="claude,codex,workbuddy,grok", help="claude、codex、workbuddy、grok,用逗号隔开")
  846. c.add_argument("--exclude", nargs="*", default=[], help="不收入的项目目录名(包含即排除)")
  847. c.add_argument("--max-chars", type=int, default=DEFAULT_MAX_CHARS)
  848. sub.add_parser("copy", help="从标准输入复制近况到剪贴板")
  849. sub.add_parser("mark-synced", help="记下同步时间并删除素材")
  850. sub.add_parser("status", help="查看同步状态")
  851. pu = sub.add_parser("push", help="把文件清单里的文档(和标准输入里的近况)直接推给 bot")
  852. pu.add_argument("--recent", action="store_true", help="从标准输入读近况,一起写进 bot")
  853. pu.add_argument("--opps-file", help="机会清单文件(第一行【机会清单】),一起交给 bot")
  854. sub.add_parser("skills", help="从 bot 取它装着的技能列表")
  855. pa = sub.add_parser("pair", help="用 bot 给的 6 位配对码换同步钥匙")
  856. pa.add_argument("code")
  857. pa.add_argument("--server", help=f"同步入口(默认 {DEFAULT_SERVER})")
  858. sc = sub.add_parser("schedule", help="自动同步:on / off / decline / status")
  859. sc.add_argument("action", choices=["on", "off", "decline", "status"])
  860. sc.add_argument("--time", help="每天几点同步,HH:MM,默认 09:00")
  861. sub.add_parser("auto-run", help="定时任务运行的命令(不用手动调用)")
  862. args = ap.parse_args()
  863. if args.cmd == "collect":
  864. args.sources = [x.strip() for x in args.sources.split(",") if x.strip()]
  865. {"collect": cmd_collect, "copy": cmd_copy, "mark-synced": cmd_mark_synced, "status": cmd_status,
  866. "push": cmd_push, "skills": cmd_skills, "pair": cmd_pair,
  867. "schedule": cmd_schedule, "auto-run": cmd_auto_run}[args.cmd](args)
  868. if __name__ == "__main__":
  869. main()

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.