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
Markdown
[](/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
- {
- "name": "dontbesilent-skills",
- "owner": {
- "name": "dontbesilent2025"
- },
- "metadata": {
- "description": "dontbesilent 商业与内容工具箱:37 个当前业务 Skill、2 个兼容入口和 1 个更新入口。",
- "version": "3.8.0"
- },
- "plugins": [
- {
- "name": "dbs",
- "description": "dontbesilent 商业工具箱的技能调度台,根据当前问题和反馈选择下一步,在对话中直接执行、澄清、组合或对照尝试 Skill。用户不知道从哪里开始、需要调整处理方法、第一次使用 dbskill、输入三位编号或查询隐藏款目录时使用;仅需推荐或可复制提示词时按请求交付。",
- "source": "./",
- "strict": true,
- "version": "3.8.0",
- "category": "business-diagnostics",
- "keywords": [
- "business",
- "router",
- "diagnosis",
- "toolkit",
- "chinese"
- ]
- },
- {
- "name": "dbs-update",
- "description": "更新官方 dbskill,并保留其他 Skill 与用户存档。用户要求更新、升级、检查 dbskill 版本,或在更新提醒后回复 1 时使用。",
- "source": "./skills/dbs-update",
- "strict": true,
- "version": "3.8.0",
- "category": "workflow-infrastructure",
- "keywords": [
- "dbskill",
- "update",
- "upgrade",
- "maintenance",
- "chinese"
- ]
- },
- {
- "name": "dbs-diagnosis",
- "description": "自动识别用户是在解决具体商业问题,还是希望全面检查商业模式,并进入对应诊断流程。用户希望拆解业务、检查商业模式或消解具体商业困境时使用。",
- "source": "./skills/dbs-diagnosis",
- "strict": true,
- "version": "3.8.0",
- "category": "business-diagnostics",
- "keywords": [
- "business-model",
- "diagnosis",
- "consulting",
- "problem-dissolution",
- "chinese"
- ]
- },
- {
- "name": "dbs-benchmark",
- "description": "用五重过滤法寻找值得模仿的对标,并排除主体差异造成的噪音。用户要求找对标、选择模仿对象或分析竞争参照时使用。",
- "source": "./skills/dbs-benchmark",
- "strict": true,
- "version": "3.8.0",
- "category": "business-diagnostics",
- "keywords": [
- "benchmark",
- "competitive-analysis",
- "imitation",
- "strategy",
- "chinese"
- ]
- },
- {
- "name": "dbs-standard-answer",
- "description": "围绕复杂问题先挖掘相关行业、学科、作者与可信理论,再比较结构同构的历史成功、失败和反例,提炼带条件的标准答案。用户需要同时获得理论解释与历史比较,或明确询问历史上如何解决、有没有经典解法、标准答案时使用;只需给现有命题、案例、PPT 或方法论找理论依据时不使用。",
- "source": "./skills/dbs-standard-answer",
- "strict": true,
- "version": "3.8.0",
- "category": "thinking-tools",
- "keywords": [
- "theory-grounding",
- "theory-application",
- "knowledge-discovery",
- "history",
- "analogy",
- "standard-answer",
- "case-study",
- "decision",
- "chinese"
- ]
- },
- {
- "name": "dbs-theory-grounding",
- "description": "理论溯源与案例重释。审查 PPT、课程、文案或方法论中的经验判断,先判断命题是否成立,再匹配并核实可信理论,用该理论重释案例并标明边界。适用于给自创理论找依据、给 PPT 补理论来源、判断一句话能否上升为理论、检查是否硬套名人;聚焦单次理论锚定,不默认展开历史同构研究。",
- "source": "./skills/dbs-theory-grounding",
- "strict": true,
- "version": "3.8.0",
- "category": "thinking-tools",
- "keywords": [
- "theory-grounding",
- "source-verification",
- "theory-application",
- "ppt",
- "methodology",
- "chinese"
- ]
- },
- {
- "name": "dbs-action",
- "description": "用阿德勒心理学框架诊断执行阻滞。用户知道该做什么却迟迟不做、反复拖延或行动中断时使用。",
- "source": "./skills/dbs-action",
- "strict": true,
- "version": "3.8.0",
- "category": "business-diagnostics",
- "keywords": [
- "psychology",
- "execution",
- "procrastination",
- "adler",
- "chinese"
- ]
- },
- {
- "name": "dbs-content",
- "description": "围绕已经确定的选题诊断内容怎么组织、论证和表达,形成创作方案。用户要把选题做成内容时使用;不负责已有稿件的逐句删改和标题开头成稿。",
- "source": "./skills/dbs-content",
- "strict": true,
- "version": "3.8.0",
- "category": "content-creation",
- "keywords": [
- "content",
- "creation",
- "copywriting",
- "social-media",
- "chinese"
- ]
- },
- {
- "name": "dbs-content-value",
- "description": "评估发布前或低流量内容会吸引谁、开头能否留人,以及流量和商业价值。适用于整体内容表现判断;不负责传播机制解读或整篇逐句改稿。",
- "source": "./skills/dbs-content-value",
- "strict": true,
- "version": "3.8.0",
- "category": "content-creation",
- "keywords": [
- "content-value",
- "audience",
- "traffic",
- "commercial-value",
- "creator",
- "chinese"
- ]
- },
- {
- "name": "dbs-content-risk-check",
- "description": "面向创作者的内容发布风险检查。逐句检查自媒体、社交媒体和内容平台的标题、正文、图片文字、字幕、口播、评论、账号资料及视频画面,分别判断平台机器可能识别什么、内容本身存在什么实质问题,并给出具体位置和最小修改动作;需要明确视频语境边界时,额外生成真实准确的三行贴片小字。用户询问「检查敏感词」「发布前排雷」「这篇内容哪里可能违规」「这条小红书能不能发」「视频上放什么声明」时使用。保留强观点、情绪张力、个人风格和传播钩子。",
- "source": "./skills/dbs-content-risk-check",
- "strict": true,
- "version": "3.8.0",
- "category": "content-creation",
- "keywords": [
- "content-risk",
- "moderation",
- "compliance",
- "creator",
- "xiaohongshu",
- "chinese"
- ]
- },
- {
- "name": "dbs-content-system",
- "description": "把本地文稿、推文、选题、案例和课程稿整理成可持续生长、可重组复用的内容工程。用户要求结构化内容资产、整理旧素材或建立主题地图时使用。",
- "source": "./skills/dbs-content-system",
- "strict": true,
- "version": "3.8.0",
- "category": "workflow-infrastructure",
- "keywords": [
- "content-system",
- "knowledge-project",
- "obsidian",
- "asset-structuring",
- "agent-workflow",
- "chinese"
- ]
- },
- {
- "name": "dbs-video-extract",
- "description": "从抖音、小红书、微信视频号等平台链接或分享文案查询作品/账号数据并提取语音文字稿,按作者和标题归档为 Markdown。用户要求解析平台视频或取得数据、文字稿时使用;需配置 TikHub 与轻抖凭证,不负责本地成片章节导航或导航视频渲染。",
- "source": "./skills/dbs-video-extract",
- "strict": true,
- "version": "3.8.0",
- "category": "content-creation",
- "keywords": [
- "video-extract",
- "transcription",
- "douyin",
- "xiaohongshu",
- "wechat-channels",
- "tikhub",
- "qingdou",
- "chinese"
- ]
- },
- {
- "name": "dbs-video-navigation",
- "description": "根据本地视频或带时间戳字幕划分章节、话题或步骤,生成可导入剪辑软件的导航条 MP4、动态分段进度和时间表。用户要求视频章节导航、顶部进度条或当前位置提示时使用;不负责平台链接数据提取或标题封面开头文案。",
- "source": "./skills/dbs-video-navigation",
- "strict": true,
- "version": "3.8.0",
- "category": "content-creation",
- "keywords": [
- "video-navigation",
- "chapters",
- "progress-bar",
- "subtitles",
- "timeline"
- ]
- },
- {
- "name": "dbs-knowledge",
- "description": "把本地文件夹建成 Agent 可稳定查找、收录和维护的知识库,并支持导航、版本判断、健康检查及 SOT 分层治理。用户要求搭建、查询、更新、整理或瘦身知识库时使用。",
- "source": "./skills/dbs-knowledge",
- "strict": true,
- "version": "3.8.0",
- "category": "workflow-infrastructure",
- "keywords": [
- "knowledge-base",
- "folder",
- "source-of-truth",
- "local-files",
- "agent-workflow",
- "chinese"
- ]
- },
- {
- "name": "dbs-title-cover-intro",
- "description": "为短视频、图文和文章生成或修改文字标题、封面文字和视频开头。先按稿件与拍摄状态把素材扩展成面向不同人群的选题供用户挑选,并询问能让观众相信作者的经历或数字,再一屏交付小红书、B 站、抖音、视频号的标题、封面与开头。用户要写标题、封面文字、开头、冷开场或多平台适配时使用;不生成封面图片或发布风险声明。",
- "source": "./skills/dbs-title-cover-intro",
- "strict": true,
- "version": "3.8.0",
- "category": "content-creation",
- "keywords": [
- "title",
- "cover",
- "video",
- "intro",
- "hook",
- "opening",
- "social-media",
- "chinese"
- ]
- },
- {
- "name": "dbs-deconstruct",
- "description": "用维特根斯坦与奥派经济学方法拆解模糊的商业概念。用户要求解释一个词、澄清概念边界或识别概念混用时使用。",
- "source": "./skills/dbs-deconstruct",
- "strict": true,
- "version": "3.8.0",
- "category": "thinking-tools",
- "keywords": [
- "wittgenstein",
- "concepts",
- "deconstruction",
- "philosophy",
- "chinese"
- ]
- },
- {
- "name": "dbs-chatroom-austrian",
- "description": "由哈耶克、米塞斯与 Claude 从奥派经济学视角展开多角色讨论。用户要求进入奥派聊天室或用奥派分析问题时使用。",
- "source": "./skills/dbs-chatroom-austrian",
- "strict": true,
- "version": "3.8.0",
- "category": "thinking-tools",
- "keywords": [
- "austrian-economics",
- "hayek",
- "mises",
- "debate",
- "philosophy",
- "chinese"
- ]
- },
- {
- "name": "dbs-chatroom",
- "description": "根据话题推荐或接受用户指定的专家,模拟多角色对话并总结分歧。用户要求专家讨论、定向聊天室或继续当前讨论时使用。",
- "source": "./skills/dbs-chatroom",
- "strict": true,
- "version": "3.8.0",
- "category": "thinking-tools",
- "keywords": [
- "chatroom",
- "multi-expert",
- "debate",
- "recommendation",
- "chinese"
- ]
- },
- {
- "name": "dbs-ai-check",
- "description": "扫描公众号长文、短视频文稿、推文等文案中的 AI 写作特征并输出检测报告,默认只诊断不改写;用户看完报告说「我想改」后,逐条追问写法背后的意图并给出修改方向。用户要求检查 AI 味、AI 痕迹或机器化表达时使用。",
- "source": "./skills/dbs-ai-check",
- "strict": true,
- "version": "3.8.0",
- "category": "content-creation",
- "keywords": [
- "ai-detection",
- "writing",
- "fingerprint",
- "content-quality",
- "chinese"
- ]
- },
- {
- "name": "dbs-plain-writing",
- "description": "按事实与功能顺序直接撰写、改写或检查产品、工具、功能、项目和更新说明,内置 ASD-STE100 清晰表达原则,核对主体、动作、指代、术语、条件与承诺强度,保留原意和用户锁定的文字,不加营销钩子、痛点渲染和抽象包装。用户要求平铺直叙地写、不要营销腔、把能力逐条写清、检查措辞歧义或只改指定一处时使用;中文为原则适配,不等于官方符合性认证。",
- "source": "./skills/dbs-plain-writing",
- "strict": true,
- "version": "3.8.0",
- "category": "content-creation",
- "keywords": [
- "writing",
- "plain-language",
- "asd-ste100",
- "documentation",
- "chinese"
- ]
- },
- {
- "name": "dbs-speak-human",
- "description": "说人话:把要发给真人看的中文,例如微信消息、群聊开场、顾客回复、私信和 Agent 回给用户的话,写成或改成像真人随口说的口语,用户提供本人写过的话时参照其口吻,去掉书面腔、客服腔和 AI 味,保留原意、事实和用户锁定的文字;调用后,本次对话里 Agent 的回复也按这套标准写。用户说「说人话」「太 AI 了」「改得口语一点」「帮我写条微信」时使用;不用于产品说明文和公众号长文,也不出 AI 痕迹检测报告。",
- "source": "./skills/dbs-speak-human",
- "strict": true,
- "version": "3.8.0",
- "category": "content-creation",
- "keywords": [
- "writing",
- "conversation",
- "plain-language",
- "ai-detection",
- "chinese"
- ]
- },
- {
- "name": "dbs-wechat-html",
- "description": "把 Markdown 转成可粘贴到微信公众号后台的 HTML,并提供 15 种内置风格。用户要求生成公众号 HTML、制作微信版本或排版公众号文章时使用。",
- "source": "./skills/dbs-wechat-html",
- "strict": true,
- "version": "3.8.0",
- "category": "content-creation",
- "keywords": [
- "wechat",
- "official-account",
- "html",
- "markdown",
- "publishing",
- "chinese"
- ]
- },
- {
- "name": "dbs-install-skill",
- "description": "将单个 Skill 或 Skill 集合安装到通用 Agents、Claude Code、Codex、WorkBuddy、Grok、Hermes Agent、Kiro、Qwen Code、Cline 等 Agent。用户要求跨 Agent 安装、同步、查看、去重或卸载 Skill 时使用。",
- "source": "./skills/dbs-install-skill",
- "strict": true,
- "version": "3.8.0",
- "category": "workflow-infrastructure",
- "keywords": [
- "install",
- "uninstall",
- "symlink",
- "claude-code",
- "codex",
- "workbuddy",
- "doubao",
- "agents",
- "skill-management",
- "chinese"
- ]
- },
- {
- "name": "dbs-skill-maker",
- "description": "制作新 Skill,或改进已有 Skill。先按改动规模给出方案并等待确认,再生成或修改文件,并用真实任务对比改动前后的表现。用户要求做 Skill、把反复出现的问题沉淀成 Skill、修改或修复 Skill、根据失败案例改进 Skill、检查或测试 Skill 时使用;只有用户明确要求分享或发布时,才准备 GitHub 仓库并验证 `npx skills add`。",
- "source": "./skills/dbs-skill-maker",
- "strict": true,
- "version": "3.8.0",
- "category": "workflow-infrastructure",
- "keywords": [
- "skill",
- "skill-creator",
- "skill-improvement",
- "requirements",
- "evaluation",
- "github",
- "agent",
- "chinese"
- ]
- },
- {
- "name": "dbs-human-dispatch",
- "description": "当用户希望将任务交给员工或协作者并跟进结果时,结合本地人员资料选择负责人,写清要求、协商工期、提供帮助并验收汇报;有飞书 CLI 时派单、读取回填和回复,缺少工具或权限时交付可转发文字。支持事件队列与可配置 Agent 接入,不承担招聘、绩效排名或惩罚。",
- "source": "./skills/dbs-human-dispatch",
- "strict": true,
- "version": "3.8.0",
- "category": "workflow-infrastructure",
- "keywords": [
- "delegation",
- "human-collaboration",
- "feishu",
- "task-management",
- "chinese"
- ]
- },
- {
- "name": "dbs-save",
- "description": "把当前诊断的关键状态保存到本地,并查看或设置存档位置。用户要求保存结论、跨会话续接或修改存档位置时使用。",
- "source": "./skills/dbs-save",
- "strict": true,
- "version": "3.8.0",
- "category": "state-management",
- "keywords": [
- "save",
- "checkpoint",
- "snapshot",
- "state",
- "persistence",
- "chinese"
- ]
- },
- {
- "name": "dbs-restore",
- "description": "恢复由 dbs-save 保存的最近诊断状态。用户要求接着上次、查看此前结论或继续未完成诊断时使用。",
- "source": "./skills/dbs-restore",
- "strict": true,
- "version": "3.8.0",
- "category": "state-management",
- "keywords": [
- "restore",
- "recall",
- "continue",
- "session",
- "chinese"
- ]
- },
- {
- "name": "dbs-report",
- "description": "把多次 dbs-save 存档合并成可交付的 Markdown 报告。用户要求汇总诊断、整理报告或生成可分享材料时使用。",
- "source": "./skills/dbs-report",
- "strict": true,
- "version": "3.8.0",
- "category": "state-management",
- "keywords": [
- "report",
- "deliverable",
- "merge",
- "markdown",
- "chinese"
- ]
- },
- {
- "name": "dbs-goal",
- "description": "提取已有约束,只追问影响执行或验收的信息,把模糊愿望整理成可行动、可检查的交付目标。用户要明确做成什么、边界和验收标准时使用;不替代概念拆解或研究问题改写。",
- "source": "./skills/dbs-goal",
- "strict": true,
- "version": "3.8.0",
- "category": "business-diagnostics",
- "keywords": [
- "goal",
- "clarity",
- "wittgenstein",
- "language-game",
- "chinese"
- ]
- },
- {
- "name": "dbs-good-question",
- "description": "把模糊提问改写成 Agent 可推理、可批评、可验证的问题说明书,并判断自动化可解程度。用户要改进问题表述、研究问题或评估 Agent 可解性时使用;任务交付目标已明确时不重复澄清目标。",
- "source": "./skills/dbs-good-question",
- "strict": true,
- "version": "3.8.0",
- "category": "thinking-tools",
- "keywords": [
- "problem",
- "question",
- "agent",
- "automation",
- "explanation",
- "hard-to-vary",
- "chinese"
- ]
- },
- {
- "name": "dbs-jtbd",
- "description": "用 Jobs to Be Done 识别具体情境中用户想推进的进展、切换方案的力量和选择标准,解释产品、服务或内容为何被选择。用户要求分析顾客任务、购买动机、替代方案或明确用 JTBD 重写提示词时使用;普通任务验收标准澄清无需套用该框架。",
- "source": "./skills/dbs-jtbd",
- "strict": true,
- "version": "3.8.0",
- "category": "thinking-tools",
- "keywords": [
- "jtbd",
- "jobs-to-be-done",
- "user-needs",
- "product-strategy",
- "decision",
- "chinese"
- ]
- },
- {
- "name": "dbs-decision",
- "description": "把需要长期跟踪的业务、关系、健康、职业、学习或投资问题建成本地决策知识工程。用户要求决策立案、结果回填、状态画像或长期复盘时使用。",
- "source": "./skills/dbs-decision",
- "strict": true,
- "version": "3.8.0",
- "category": "state-management",
- "keywords": [
- "decision",
- "tracking",
- "knowledge-project",
- "personal",
- "snapshot",
- "concept-library",
- "chinese"
- ]
- },
- {
- "name": "dbs-learning",
- "description": "把课题拆成连续学习文章,并根据用户反馈调整后续深度、角度和节奏。用户要求系统学习一个主题、继续下一篇或按反馈调整课程时使用。",
- "source": "./skills/dbs-learning",
- "strict": true,
- "version": "3.8.0",
- "category": "learning",
- "keywords": [
- "learning",
- "course",
- "adaptive-learning",
- "feedback",
- "chinese"
- ]
- },
- {
- "name": "dbs-spread",
- "description": "解释一段已有内容为什么引发共鸣、情绪或分享,识别传播机制、有效立场和受众动机,并提炼讨论方向。适用于传播机制解读;不负责整篇逐句改稿或整体流量和商业价值评估。",
- "source": "./skills/dbs-spread",
- "strict": true,
- "version": "3.8.0",
- "category": "content-creation",
- "keywords": [
- "content",
- "psychology",
- "transmission",
- "resonance",
- "chinese"
- ]
- },
- {
- "name": "dbs-resonate",
- "description": "诊断已经写成的稿件哪里没有打中目标受众,结合原句解释共鸣断点并提出具体删改建议。适用于稿件修订;不负责整体流量与商业价值评估,也不以解释已发布内容的传播机制为主要交付。",
- "source": "./skills/dbs-resonate",
- "strict": true,
- "version": "3.8.0",
- "category": "content-creation",
- "keywords": [
- "draft",
- "resonance",
- "content",
- "diagnosis",
- "chinese"
- ]
- },
- {
- "name": "dbs-script-flow",
- "description": "检查短视频逐字稿的段落衔接、信息密度和口播流畅度,定位观众可能划走的位置。用户要求检查逻辑延续、文稿顺畅度或流失风险时使用。",
- "source": "./skills/dbs-script-flow",
- "strict": true,
- "version": "3.8.0",
- "category": "content-creation",
- "keywords": [
- "script",
- "flow",
- "continuity",
- "completion-rate",
- "short-video",
- "chinese"
- ]
- },
- {
- "name": "dbs-sync-to-dondon",
- "description": "同步给 dondon:读取本机 Claude Code、Codex、WorkBuddy、Grok 最近的聊天记录,在本地隐去敏感信息后写成 800 字以内的工作近况,并找出聊天里用到的文档;用户确认后推给 dondon bot(未配置推送的复制给用户粘贴),让它的早报和提醒贴着用户手上的事;用户同意后可每天自动同步(由 bot 那边写近况,本机不需要 Agent 在场)。用户说「同步给 dondon」「把近况发给 bot」「开启/停止自动同步」「sync to dondon」时使用;不上传密钥密码,聊天摘录只在用户同意的自动同步里上传。",
- "source": "./skills/dbs-sync-to-dondon",
- "strict": true,
- "version": "3.8.0",
- "category": "workflow-infrastructure",
- "keywords": [
- "dondon",
- "sync",
- "agent-history",
- "bot",
- "chinese"
- ]
- },
- {
- "name": "dbs-computer-use",
- "description": "一个入口操控电脑,适用于 macOS、Windows、Linux 和各种 Agent:先判断要不要点界面,再按当前工具清单选路线(Cua Driver 优先,agent-desktop 兜底,Agent 自带的 computer use 第三),缺工具时说明装了能做到什么并给出官方安装命令,经同意再装;尽量后台操作、不抢鼠标,敏感动作先确认,操作后读回。用户说「在电脑上帮我…」「去浏览器里看看…」「操作这个 App」「computer use」时使用;不替用户输入密码或付款,不用 Claude in Chrome。触发:/dbs-computer-use。",
- "source": "./skills/dbs-computer-use",
- "strict": true,
- "version": "3.8.0",
- "category": "workflow-infrastructure",
- "keywords": [
- "computer-use",
- "desktop-automation",
- "browser",
- "macos",
- "windows",
- "linux",
- "chinese"
- ]
- }
- ]
- }
README.md · README · 298 lines
- # dbskill
- 简体中文 | [English](README.en.md) | [日本語](README.ja.md) | [한국어](README.ko.md) | [繁體中文](README.zh-TW.md)
- [](VERSION)
- [](https://skills.sh/b/dontbesilent2025/dbskill)
- [](LICENSE)
- **本次更新:** 安装 Skill 时可自动同步到 Antigravity 的全局目录,供各工作区调用。
- ## dbskill 是什么
- dbskill 是 dontbesilent 制作的中文 AI Skills 工具箱,共 37 个 Skill。安装到豆包、WorkBuddy、Claude Code、Codex 等支持 Skills 的 Agent 后,可以在对话里直接使用
- Skill 是一套写给 Agent 的做事方法。装好 dbskill 后,你可以让 Agent:
- - 判断一门生意的问题出在哪,比如续费低、客户嫌贵
- - 找值得学的同行,看对方具体怎么做
- - 把一个选题做成内容方案,检查稿子哪里没打动人
- - 给一条视频写标题、封面文字和开头,发布前检查有没有违规风险
- - 分析自己为什么知道该做却一直没做
- - 把本地文件夹整理成可以随时查询的知识库
- 方法资料来自 dontbesilent 的 16,152 条公开推文,整理成 4,176 个知识原子。作者:[@dontbesilent](https://x.com/dontbesilent)
- ## 快速开始
- **第 1 步:安装**
- 在终端运行:
- ```bash
- npx -y skills add dontbesilent2025/dbskill -g --all
- ```
- 使用 Claude Code 插件市场或只装单个 Skill,见下文[安装详情](#安装详情)
- 在 Grok Bot 里使用:直接添加现成的 [dbs 创业教练](https://x.ai/bot/kpZtlm5CADHoXaaAqTV5Z) 或 [dbs 内容教练](https://x.ai/bot/qonh7lyBBYsbUXsR9LtO2),用法见[在 Grok Bot 里使用](#在-grok-bot-里使用)
- **第 2 步:把问题交给 `/dbs`**
- 在 Agent 对话框输入 `/dbs`,后面写上你的情况和问题。信息不完整也可以:
- ```text
- /dbs 我做少儿编程课,有 40 个付费学员,但续费率很低。我不知道该先检查产品、定价还是客户匹配
- ```
- 第一次使用,可以先输入 `/dbs 新手入门`,了解能处理哪些任务
- **第 3 步:在同一个对话里继续**
- 收到结果后,直接补充事实、材料或修改意见,不用重新输入命令。换一个新目标时,再输入一次 `/dbs`
- ## 在 Grok Bot 里使用
- 在 Grok Bot 里不用敲命令,直接添加现成的教练。第一次聊天时,它会自己装好 dbskill
- | 教练 | 能帮你做什么 | 添加链接 |
- | --- | --- | --- |
- | dbs 创业教练 | 想清楚生意卡在哪、这周先做哪一件事;愿意的话,每周一主动找你复盘 | https://x.ai/bot/kpZtlm5CADHoXaaAqTV5Z |
- | dbs 内容教练 | 定选题,写标题、封面和开头,检查稿子,复盘每条内容的表现;愿意的话,每周五主动找你复盘 | https://x.ai/bot/qonh7lyBBYsbUXsR9LtO2 |
- **怎么用**
- 1. 打开上面的链接,点「Add to Grok Bot」,在 Grok Bot App 里确认添加
- 2. 给新添加的教练发一句「你好」。它会先花几分钟装好 dbskill,再问你几个关于生意或账号的问题
- 3. 之后直接说你的问题,例如「我的课续费率很低,先查哪里」「帮我给这条视频想个标题」
- **教练说装不上时**
- 把下面这段原样发给它。用内容教练的,把最后的 `startup` 换成 `content`:
- ```text
- 请在你的运行环境里执行下面两条命令安装 dbskill,把输出原样告诉我:
- git clone --depth 1 https://github.com/dontbesilent2025/dbskill /tmp/dbskill 2>/dev/null || git -C /tmp/dbskill pull --ff-only
- python3 /tmp/dbskill/tools/grok/install.py --coach startup
- ```
- 不用教练、只想在自己的 Grok Bot 里装 dbskill,也发这段,把 `startup` 换成 `all`,会装好全部 29 个公开 Skill
- ## /dbs 怎样安排 Skill
- `/dbs` 是 dbskill 的技能调度台。它先看你要的最终结果,再决定用哪几个 Skill、按什么顺序用。能少用就少用:简单问题直接回答,一个 Skill 够用就只用一个
- 常见的安排有 6 种:
- 1. **只用一个**:诊断商业模式,只用 `dbs-diagnosis`
- 2. **按顺序接着做**:后一步要用前一步的结果。`dbs-content` 给出创作方案,你写完稿子,再用 `dbs-content-risk-check` 检查发布风险
- 3. **各做各的**:几件事互不相关。`dbs-ai-check` 查 AI 味,`dbs-wechat-html` 排版,两份结果分别交给你
- 4. **先判断,再决定做不做**:`dbs-content-value` 先判断选题值不值得做,值得再用 `dbs-content` 出方案
- 5. **分别分析,再比较**:同一个问题可能有几种原因。稿子流量低,`dbs-content-value` 和 `dbs-resonate` 各自给出原因,`/dbs` 再比较
- 6. **做完检查,再修改**:要求高的文字,`dbs-plain-writing` 写完后用 `dbs-ai-check` 检查,再按问题修改
- 需要你定方向时,`/dbs` 会把选项列给你,不替你选。开始前,它会说明打算怎么安排、为什么这样安排
- ## 全部 Skill
- 已经知道要用哪个 Skill 时,可以直接输入它的命令。每个 Skill 的适用时机、输入示例和边界,见[新手入门与 Skill 全目录](docs/新手入门.md#skill-全目录)
- ### 入口
- | 命令 | 用途 |
- | --- | --- |
- | [`/dbs`](skills/dbs/SKILL.md) | 根据你的问题选择和安排 Skill,在当前对话里推进 |
- ### 商业判断与问题澄清
- | 命令 | 用途 |
- | --- | --- |
- | [`/dbs-diagnosis`](skills/dbs-diagnosis/SKILL.md) | 判断一个商业问题是否成立,或全面检查一门生意,给出明天要做的第一件事 |
- | [`/dbs-benchmark`](skills/dbs-benchmark/SKILL.md) | 筛选值得模仿的同行,拆出对方获客、转化、交付的具体做法 |
- | [`/dbs-jtbd`](skills/dbs-jtbd/SKILL.md) | 分析顾客为什么选择或放弃一个产品 |
- | [`/dbs-goal`](skills/dbs-goal/SKILL.md) | 把模糊的愿望整理成能检查的目标和完成标准 |
- | [`/dbs-good-question`](skills/dbs-good-question/SKILL.md) | 把模糊的问题改写清楚,判断哪些部分能交给 Agent |
- | [`/dbs-deconstruct`](skills/dbs-deconstruct/SKILL.md) | 拆解一个说不清的概念,讲清它在不同场合的意思 |
- | [`/dbs-theory-grounding`](skills/dbs-theory-grounding/SKILL.md) | 检查课程、PPT 或方法论里的判断,找到可信的理论依据 |
- | [`/dbs-standard-answer`](skills/dbs-standard-answer/SKILL.md) | 研究一个问题的相关理论和历史案例,给出带条件的标准答案 |
- ### 内容创作与发布
- | 命令 | 用途 |
- | --- | --- |
- | [`/dbs-content`](skills/dbs-content/SKILL.md) | 把已定的选题做成内容方案:形式、平台、结构和表达 |
- | [`/dbs-title-cover-intro`](skills/dbs-title-cover-intro/SKILL.md) | 先定选题,再写小红书、B 站、抖音、视频号的标题、封面文字和开头 |
- | [`/dbs-resonate`](skills/dbs-resonate/SKILL.md) | 找出写好的稿子哪里没打动目标受众,给出删改建议 |
- | [`/dbs-script-flow`](skills/dbs-script-flow/SKILL.md) | 检查短视频逐字稿的衔接和口播流畅度,标出观众可能划走的位置 |
- | [`/dbs-content-value`](skills/dbs-content-value/SKILL.md) | 判断内容会吸引谁、开头能不能留住人,以及可能的流量和商业价值 |
- | [`/dbs-spread`](skills/dbs-spread/SKILL.md) | 解释一条已有反响的内容为什么让人共鸣或转发 |
- | [`/dbs-ai-check`](skills/dbs-ai-check/SKILL.md) | 标出文案里的 AI 写作痕迹 |
- | [`/dbs-content-risk-check`](skills/dbs-content-risk-check/SKILL.md) | 发布前逐句检查平台审核风险,给出最小的修改方法 |
- | [`/dbs-plain-writing`](skills/dbs-plain-writing/SKILL.md) | 按事实顺序写产品、功能和更新说明,不加营销包装 |
- | [`/dbs-speak-human`](skills/dbs-speak-human/SKILL.md) | 把微信消息、顾客回复和 Agent 的回复改成像真人随口说的口语 |
- | [`/dbs-wechat-html`](skills/dbs-wechat-html/SKILL.md) | 把 Markdown 排成能粘贴到公众号后台的 HTML |
- ### AI 味三件套
- 觉得文字「太 AI」时,先分清这段文字给谁看,再选 Skill:
- | 命令 | 处理什么文字 | 交给你什么 |
- | --- | --- | --- |
- | [`/dbs-ai-check`](skills/dbs-ai-check/SKILL.md) | 公众号长文、短视频文稿、推文 | 检测报告,逐处标出 AI 写作特征;你说「我想改」后逐条追问你本来想怎么说,不直接替你重写 |
- | [`/dbs-speak-human`](skills/dbs-speak-human/SKILL.md) | 微信消息、群聊开场、顾客回复、私信、Agent 回给你的话 | 改好的全文,附每处改动和原因 |
- | [`/dbs-plain-writing`](skills/dbs-plain-writing/SKILL.md) | 产品、功能、项目和更新说明 | 按事实顺序写成的成稿,不加营销包装 |
- ### 视频处理
- | 命令 | 用途 |
- | --- | --- |
- | [`/dbs-video-extract`](skills/dbs-video-extract/SKILL.md) | 根据平台链接取得作品数据和语音文字稿;需要外部服务凭证 |
- | [`/dbs-video-navigation`](skills/dbs-video-navigation/SKILL.md) | 为本地视频划分章节,生成可导入剪辑软件的导航条 |
- ### 行动、学习与决策
- | 命令 | 用途 |
- | --- | --- |
- | [`/dbs-action`](skills/dbs-action/SKILL.md) | 分析知道该做却一直没做的原因,给出今天能做的一步 |
- | [`/dbs-learning`](skills/dbs-learning/SKILL.md) | 把一个课题拆成连续的学习文章,按你的反馈调整下一篇 |
- | [`/dbs-decision`](skills/dbs-decision/SKILL.md) | 为需要长期跟踪的决策建立本地记录,之后回填结果和复盘 |
- ### 存档与报告
- | 命令 | 用途 |
- | --- | --- |
- | [`/dbs-save`](skills/dbs-save/SKILL.md) | 把当前对话的结论和下一步保存到本机 |
- | [`/dbs-restore`](skills/dbs-restore/SKILL.md) | 读取上次的存档,接着处理 |
- | [`/dbs-report`](skills/dbs-report/SKILL.md) | 把多份存档合并成一份报告 |
- ### 多视角讨论
- | 命令 | 用途 |
- | --- | --- |
- | [`/dbs-chatroom`](skills/dbs-chatroom/SKILL.md) | 请几位专家角色围绕一个话题分别发言,最后汇总 |
- | [`/dbs-chatroom-austrian`](skills/dbs-chatroom-austrian/SKILL.md) | 用哈耶克、米塞斯两位奥派经济学家的视角讨论问题 |
- ### 资料与工具
- | 命令 | 用途 |
- | --- | --- |
- | [`/dbs-knowledge`](skills/dbs-knowledge/SKILL.md) | 把本地文件夹建成 Agent 能查找、收录和维护的知识库 |
- | [`/dbs-content-system`](skills/dbs-content-system/SKILL.md) | 把一批旧文稿整理成可以拆分、复用的内容资料库 |
- | [`/dbs-human-dispatch`](skills/dbs-human-dispatch/SKILL.md) | 把任务派给员工或协作者,跟进进度并验收结果 |
- | [`/dbs-skill-maker`](skills/dbs-skill-maker/SKILL.md) | 制作新的 Skill,或改进已有的 Skill |
- | [`/dbs-install-skill`](skills/dbs-install-skill/SKILL.md) | 把 Skill 安装到多个 Agent,并清理重复的入口 |
- | [`/dbs-computer-use`](skills/dbs-computer-use/SKILL.md) | 让 Agent 在电脑上操作网页和桌面 App,尽量在后台进行、不抢鼠标;缺工具时先说明再引导安装,付款、删除、发送前停下等你确认 |
- ## 安装详情
- 以下命令都在终端运行,不要作为聊天内容发给 Agent
- ### Skills CLI
- ```bash
- npx -y skills add dontbesilent2025/dbskill -g --all
- ```
- `-g` 表示全局安装,`--all` 表示安装到 Skills CLI 识别的所有 Agent。只想装到一个 Agent 时,删掉 `--all`,按提示选择
- ### Claude Code 插件市场
- ```bash
- claude plugin marketplace add dontbesilent2025/dbskill
- claude plugin install dbs@dontbesilent-skills
- ```
- 插件方式下,命令前面要加 `dbs:`,例如 `/dbs:dbs`、`/dbs:dbs-diagnosis`
- 只装一个 Skill 时,安装对应的插件,例如:
- ```bash
- claude plugin install dbs-diagnosis@dontbesilent-skills
- ```
- 
- ### 装好后没看到命令
- 先确认安装命令运行成功,并且装到的是你正在用的 Agent。Skills CLI 安装用短命令,例如 `/dbs`;Claude Code 插件用带 `dbs:` 的命令。具体名称以 Agent 里显示的为准
- ## 更多用法
- ### 直接调用某个 Skill
- 在命令后写上问题、材料和你想要的结果:
- ```text
- /dbs-diagnosis 我做收纳咨询,客单价 3,000 元。最近 10 个咨询里有 6 个说贵,3 个没有回复。请判断下一步先核实什么
- ```
- ```text
- /dbs-title-cover-intro 这是准备拍的短视频稿,请按小红书发布,给我标题、封面文字和开头:粘贴文稿
- ```
- 提问时附上这些信息,结果会更准确:
- - 你手上已有的事实和数字,例如价格、人数、成交情况
- - 完整的稿子或材料,不要只给摘要
- - 你想要什么结果,例如判断、方案,还是能直接用的文字
- 需要读取本地文件、联网或处理视频的 Skill,Agent 还要有相应的权限或工具,具体见各 Skill 的说明
- ### 使用视频里的三位编号
- 在 dontbesilent 的视频里拿到三位编号后,输入:
- ```text
- /dbs 123
- ```
- 把 `123` 换成视频给出的编号。想看当前所有编号,输入 `/dbs 给我所有隐藏级 skill`。编号内容在使用时从 GitHub 读取,Agent 需要能访问 GitHub
- ### 跨对话保留结论
- 用 `/dbs-save` 保存当前的结论,下次用 `/dbs-restore` 接着处理。存档保存在本机 `~/.dbs/`
- ## 仓库资料
- 安装 Skill 不会下载这些资料,需要时在仓库里查阅
- | 资料 | 用途 |
- | --- | --- |
- | [dontbesilent 推文集(Markdown)](books/dontbesilent-开源推文集.md) | 搜索、阅读,或交给 AI 分析 |
- | [dontbesilent 推文集(PDF)](books/dontbesilent-开源推文集.pdf) | 阅读和保存 |
- | [原子库说明](知识库/原子库/README.md) | 数据范围、字段和使用方式 |
- | [知识原子数据](知识库/原子库/atoms.jsonl) | 自建检索、分析或 RAG |
- | [Skill 知识包](知识库/Skill知识包) | 按 Skill 整理的方法资料 |
- ## 更新与帮助
- 在 Agent 对话里说:
- ```text
- 更新 dbskill
- ```
- 更新会同步官方 dbskill,保留 `~/.dbs/` 里的存档和记录,并自动清理已经下线的旧 Skill。手动清理方法见[新手入门](docs/新手入门.md#怎样更新)。历史改动见[更新记录](https://github.com/dontbesilent2025/dbskill/commits/main)
- - [新手入门与 Skill 全目录](docs/新手入门.md)
- - [提交问题或建议](https://github.com/dontbesilent2025/dbskill/issues)
- - [付费答疑群说明](https://mp.weixin.qq.com/s/RpwNjMo4M_er4GOrfCYt1g)
- - 作者:[@dontbesilent](https://x.com/dontbesilent) · [小红书](https://xhslink.com/m/637xuspR4iI) · [抖音](https://v.douyin.com/pRUDhpBqOrc/)
- ## 贡献者
- `dbs-content-risk-check` 的敏感词检查能力由以下共创者共同完善:
- - [@Ronnie2025](https://github.com/Ronnie2025)
- - [@非著名投放小沈](https://xhslink.cn/m/4NSBjmZTC1j)
- ## 许可证
- 本项目版权归 dontbesilent 所有,保留所有权利,完整条款见 [LICENSE](LICENSE)。
- - 你可以免费安装和使用 Skill,包括用它做自己的生意、给自己的客户提供服务,也可以在自己的设备上修改后自用。
- - 未经书面许可,不得转载、再分发、打包进其他产品、出售或公开发布修改版,也不得用于训练 AI 模型。分享本仓库链接不受限制。
- - `books/` 目录只供免费阅读,见 [books/LICENSE](books/LICENSE)。
- - 2026-11-02 之前发布的版本,仍按当时的 CC BY-NC 4.0 授权。
- 申请授权请发邮件至 openmarshall@gmail.com。
skills/dbs-sync-to-dondon/scripts/sync_material.py · Bundled script · 989 lines · 1 finding marked
- #!/usr/bin/env python3
- """从本机 Agent 的聊天记录里整理出写「近况」用的素材,并管理同步状态。
- 只用标准库,只读聊天记录;collect 不联网,push 经 HTTPS 推给配对过的 bot。素材文件和状态都放在 ~/.dondon-sync/,权限 600。
- 子命令:
- collect 整理素材:只取上次同步以后(或最近 N 天)的记录,只留用户说的话和每轮的最后回答,
- 先隐去密钥、手机号、证件号、银行卡号、邮箱等,再按字数上限截断,写进素材文件。
- copy 从标准输入读近况全文,复制到剪贴板。
- mark-synced 记下这次同步的时间,并删掉素材文件。用户确认发出后再运行。
- status 显示上次同步时间和能找到的聊天记录位置。
- push 把 collect 找出的文档隐去敏感信息后推到 bot 的知识库,近况(--recent,标准输入)直接写进 bot。
- 需要先用 pair 配对;没配对的电脑只能用 copy。
- skills 从 bot 取它装着的技能列表,写机会清单时只能从这里选。
- pair <码> 用 bot 给的 6 位配对码换同步钥匙(客户的正常用法);之后 push 走 HTTPS,只认 Skill 自带的证书。
- schedule 自动同步:on [--time HH:MM] 每天定时同步一次(macOS);off 关掉;decline 记下用户不要;status 查看。
- auto-run 定时任务实际运行的命令:整理素材 → 请本机 Agent(不开任何工具)写近况和机会清单 → 推送 → 记同步时间。
- 不同步的内容:API 密钥、令牌、密码、私钥、助记词。文档里只要出现一处,整份文档不传;文件名像存这些东西的文档也不传。
- 手机号、邮箱、证件号、银行卡号在聊天素材、文档、近况和机会清单里一律先换成「〔已隐去〕」。
- 聊天记录来源:Claude Code、Codex、WorkBuddy、Grok CLI。豆包的对话存在云端,本机读不到。
- """
- import argparse
- import glob
- import json
- import os
- import re
- import shutil
- import subprocess
- import sys
- from datetime import datetime, timedelta, timezone
- from urllib.parse import unquote
- import socket
- import ssl
- import time
- import urllib.error
- import urllib.request
- STATE_DIR = os.path.expanduser("~/.dondon-sync")
- STATE_FILE = os.path.join(STATE_DIR, "state.json")
- MATERIAL_FILE = os.path.join(STATE_DIR, "material.md")
- CLAUDE_GLOB = os.path.expanduser("~/.claude/projects/*/*.jsonl")
- CODEX_GLOB = os.path.expanduser("~/.codex/sessions/**/*.jsonl")
- WORKBUDDY_GLOB = os.path.expanduser("~/.workbuddy/projects/*/*.jsonl")
- GROK_GLOB = os.path.expanduser("~/.grok/sessions/*/*/chat_history.jsonl")
- CONFIG_FILE = os.path.join(STATE_DIR, "config.json")
- FILES_LIST = os.path.join(STATE_DIR, "files.json")
- STAGE_DIR = os.path.join(STATE_DIR, "stage")
- REMOTE_DIR_NAME = "近期工作文件"
- OWNER_LINE = "这是客户本人的资料,不是别人的。客户问到自己(我是谁、我做什么、我说过什么)和自己的生意、内容、产品时,先在这里找。"
- SYNC_MARK = "【近况同步】"
- USER_MSG_LIMIT = 500 # 每条用户消息最多保留的字数
- ANSWER_LIMIT = 600 # 每轮最后回答最多保留的字数
- DEFAULT_MAX_CHARS = 30000 # 素材总字数上限
- SESSION_MIN_BUDGET = 1000 # 每个会话至少分到的字数
- DEFAULT_DAYS = 7 # 写近况看最近几天的聊天:一周才看得出主线和卡点
- FILE_DAYS = 14 # 文档取最近几天用到的:每次整批替换,所以每批都要带够两周
- MAX_DAYS = 30
- REDACT = "〔已隐去〕"
- REDACT_PATTERNS = [
- re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----.*?-----END [A-Z ]*PRIVATE KEY-----", re.S),
- re.compile(r"\b(?:sk|pk|rk)-[A-Za-z0-9_\-]{12,}"),
- re.compile(r"\b(?:ddb|ghp|gho|ghs|github_pat|xox[abpr]|glpat|AKIA|ASIA)[_\-]?[A-Za-z0-9_\-]{10,}"),
- re.compile(r"\beyJ[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{5,}"), # JWT
- re.compile(r"(?i)\b(?:bearer|token|api[_\-]?key|secret|password|passwd|pwd|密码|口令|密钥)\s*[:=:]\s*\S+"),
- re.compile(r"\b[A-Fa-f0-9]{32,}\b"),
- re.compile(r"\b[A-Za-z0-9+/]{40,}={0,2}"),
- re.compile(r"[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}"),
- re.compile(r"(?<!\d)\d{17}[\dXx](?!\d)"), # 身份证
- re.compile(r"(?<!\d)\d{16,19}(?!\d)"), # 银行卡
- re.compile(r"(?<!\d)(?:\+?86[\- ]?)?1[3-9]\d{9}(?!\d)"), # 手机号
- ]
- # 核心秘密:文档里只要出现一处,整份不传(隐去还不够:留着上下文也可能被拼回去)。这些东西对 bot 帮用户做事没有用处。
- SECRET_VALUE = r"[\"'`]?[A-Za-z0-9_\-+/=.]{12,}"
- SECRET_PATTERNS = [
- re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----"),
- re.compile(r"\b(?:sk|pk|rk)-[A-Za-z0-9_\-]{16,}"),
- re.compile(r"\b(?:ghp|gho|ghs|github_pat|xox[abpr]|glpat|AKIA|ASIA|ddb|dds)[_\-]?[A-Za-z0-9_\-]{12,}"),
- re.compile(r"\beyJ[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{5,}"), # JWT
- re.compile(r"(?i)\b(?:api[_\-]?key|secret[_\-]?key|access[_\-]?key|client[_\-]?secret|app[_\-]?secret|auth[_\-]?token|"
- r"access[_\-]?token|password|passwd|bearer)\s*[:=:]?\s*" + SECRET_VALUE),
- re.compile(r"(?:密钥|密码|口令|私钥|助记词|令牌)\s*[:=:]\s*" + SECRET_VALUE),
- ]
- SECRET_NAME_RE = re.compile(r"(?i)(api[_\- ]?keys?|secrets?|passw(?:or)?ds?|credentials?|\.env\b|密钥|密码|口令|私钥|凭证|助记词)")
- def secret_hit(text):
- return any(p.search(text) for p in SECRET_PATTERNS)
- # 宿主自动注入、不是用户本人说的话
- INJECTED_PREFIXES = (
- "<", "# AGENTS.md instructions", "Caveat:", "[Request interrupted", "This session is being continued",
- "Base directory for this skill", "[SYSTEM NOTIFICATION",
- )
- def redact(text):
- for p in REDACT_PATTERNS:
- text = p.sub(REDACT, text)
- return text
- def clip(text, limit):
- text = re.sub(r"```.*?```", "〔代码略〕", text, flags=re.S)
- text = re.sub(r"(?m)^#{1,6}\s+", "", text) # 去掉标题符号,免得和会话标题混在一起
- text = re.sub(r"[ \t]+", " ", text)
- text = re.sub(r"\n{3,}", "\n\n", text).strip()
- return text if len(text) <= limit else text[:limit] + "……"
- def parse_time(s):
- if not s:
- return None
- try:
- return datetime.fromisoformat(str(s).replace("Z", "+00:00"))
- except ValueError:
- return None
- def is_user_words(text):
- t = text.lstrip()
- return bool(t) and not t.startswith(INJECTED_PREFIXES) and SYNC_MARK not in t
- def project_name(cwd):
- return os.path.basename(cwd.rstrip("/")) if cwd else "未知目录"
- def read_jsonl(path):
- try:
- with open(path, encoding="utf-8", errors="replace") as f:
- for line in f:
- try:
- yield json.loads(line)
- except ValueError:
- continue
- except OSError:
- return
- def claude_sessions(since, refs=None):
- """Claude Code:~/.claude/projects/<目录>/<会话>.jsonl。子 Agent 的记录在 subagents/ 下,不读。"""
- for path in glob.glob(CLAUDE_GLOB):
- if datetime.fromtimestamp(os.path.getmtime(path), timezone.utc) < since:
- continue
- title, cwd, turns, last_answer = None, None, [], None
- for o in read_jsonl(path):
- kind = o.get("type")
- if kind == "custom-title":
- title = o.get("customTitle") or title
- continue
- if kind not in ("user", "assistant") or o.get("isSidechain") or o.get("isMeta"):
- continue
- ts = parse_time(o.get("timestamp"))
- if not ts or ts < since:
- continue
- cwd = o.get("cwd") or cwd
- content = (o.get("message") or {}).get("content")
- if kind == "user":
- if isinstance(content, str):
- texts = [content]
- elif isinstance(content, list):
- texts = [b.get("text", "") for b in content if isinstance(b, dict) and b.get("type") == "text"]
- else:
- texts = []
- texts = [t for t in texts if is_user_words(t)]
- if texts:
- note_refs(refs, texts, ts, "Claude Code", title)
- if turns and last_answer:
- turns[-1]["answer"] = last_answer
- last_answer = None
- turns.append({"time": ts, "user": "\n".join(texts), "answer": None})
- elif isinstance(content, list):
- note_refs(refs, [b.get("input") for b in content if isinstance(b, dict) and b.get("type") == "tool_use"],
- ts, "Claude Code", title)
- texts = [b.get("text", "") for b in content if isinstance(b, dict) and b.get("type") == "text"]
- if any(t.strip() for t in texts):
- last_answer = "\n".join(texts)
- if turns and last_answer:
- turns[-1]["answer"] = last_answer
- if turns:
- yield {"source": "Claude Code", "title": title, "project": project_name(cwd), "turns": turns}
- def codex_sessions(since, refs=None):
- """Codex:~/.codex/sessions/年/月/日/rollout-*.jsonl。parent_thread_id 不为空的是子线程,不读。"""
- for path in glob.glob(CODEX_GLOB, recursive=True):
- if datetime.fromtimestamp(os.path.getmtime(path), timezone.utc) < since:
- continue
- cwd, turns, last_answer, child = None, [], None, False
- for o in read_jsonl(path):
- p = o.get("payload") or {}
- if o.get("type") == "session_meta":
- child = bool(p.get("parent_thread_id"))
- cwd = p.get("cwd")
- continue
- if o.get("type") != "response_item" or p.get("type") not in ("message", "function_call", "custom_tool_call"):
- continue
- ts = parse_time(o.get("timestamp")) or datetime.fromtimestamp(os.path.getmtime(path), timezone.utc)
- if ts < since:
- continue
- if p.get("type") != "message":
- if not child:
- note_refs(refs, p.get("arguments") or p.get("input"), ts, "Codex", None)
- continue
- texts = [b.get("text", "") for b in p.get("content") or [] if isinstance(b, dict)]
- if p.get("role") == "user":
- texts = [t for t in texts if is_user_words(t)]
- if texts:
- if not child:
- note_refs(refs, texts, ts, "Codex", None)
- if turns and last_answer:
- turns[-1]["answer"] = last_answer
- last_answer = None
- turns.append({"time": ts, "user": "\n".join(texts), "answer": None})
- elif p.get("role") == "assistant" and any(t.strip() for t in texts):
- last_answer = "\n".join(texts)
- if child:
- continue
- if turns and last_answer:
- turns[-1]["answer"] = last_answer
- if turns:
- yield {"source": "Codex", "title": None, "project": project_name(cwd), "turns": turns}
- def ms_time(v):
- try:
- return datetime.fromtimestamp(int(v) / 1000, timezone.utc)
- except (TypeError, ValueError, OverflowError, OSError):
- return None
- def block_texts(content):
- if isinstance(content, str):
- return [content]
- if isinstance(content, list):
- return [b.get("text", "") for b in content if isinstance(b, dict) and isinstance(b.get("text"), str)]
- return []
- def workbuddy_sessions(since, refs=None):
- """WorkBuddy:~/.workbuddy/projects/<目录>/<会话>.jsonl,条目 type=message(role user/assistant)、function_call。"""
- for path in glob.glob(WORKBUDDY_GLOB):
- if datetime.fromtimestamp(os.path.getmtime(path), timezone.utc) < since:
- continue
- title, cwd, turns, last_answer = None, None, [], None
- for o in read_jsonl(path):
- kind = o.get("type")
- if kind == "ai-title":
- title = o.get("aiTitle") or title
- continue
- cwd = o.get("cwd") or cwd
- ts = ms_time(o.get("timestamp")) or parse_time(o.get("timestamp"))
- if not ts or ts < since:
- continue
- if kind == "function_call":
- note_refs(refs, o.get("arguments"), ts, "WorkBuddy", title)
- continue
- if kind != "message":
- continue
- texts = block_texts(o.get("content"))
- if o.get("role") == "user":
- texts = [t for t in texts if is_user_words(t)]
- if texts:
- note_refs(refs, texts, ts, "WorkBuddy", title)
- if turns and last_answer:
- turns[-1]["answer"] = last_answer
- last_answer = None
- turns.append({"time": ts, "user": "\n".join(texts), "answer": None})
- elif o.get("role") == "assistant" and any(t.strip() for t in texts):
- last_answer = "\n".join(texts)
- if turns and last_answer:
- turns[-1]["answer"] = last_answer
- if turns:
- yield {"source": "WorkBuddy", "title": title, "project": project_name(cwd), "turns": turns}
- GROK_QUERY = re.compile(r"<user_query>\s*(.*?)\s*</user_query>", re.S)
- def grok_sessions(since, refs=None):
- """Grok CLI:~/.grok/sessions/<编码后的目录>/<会话>/chat_history.jsonl,条目 type=user/assistant/tool_result。
- 用户的话包在 <user_query> 里,其余是宿主注入的环境说明。条目没有时间,用文件修改时间。"""
- for path in glob.glob(GROK_GLOB):
- mtime = datetime.fromtimestamp(os.path.getmtime(path), timezone.utc)
- if mtime < since:
- continue
- cwd = unquote(os.path.basename(os.path.dirname(os.path.dirname(path))))
- turns, last_answer = [], None
- for o in read_jsonl(path):
- kind = o.get("type")
- if kind == "user":
- texts = []
- for t in block_texts(o.get("content")):
- m = GROK_QUERY.search(t)
- if m:
- texts.append(m.group(1))
- elif is_user_words(t):
- texts.append(t)
- if texts:
- note_refs(refs, texts, mtime, "Grok", None)
- if turns and last_answer:
- turns[-1]["answer"] = last_answer
- last_answer = None
- turns.append({"time": mtime, "user": "\n".join(texts), "answer": None})
- elif kind == "assistant":
- note_refs(refs, {k: v for k, v in o.items() if k != "content"}, mtime, "Grok", None)
- texts = block_texts(o.get("content"))
- if any(t.strip() for t in texts):
- last_answer = "\n".join(texts)
- if turns and last_answer:
- turns[-1]["answer"] = last_answer
- if turns:
- yield {"source": "Grok", "title": None, "project": project_name(cwd), "turns": turns}
- # ---------------------------------------------------------------- 会话里用到的文件
- HOME = os.path.expanduser("~")
- ICLOUD = os.path.join(HOME, "Library", "Mobile Documents", "com~apple~CloudDocs")
- PATH_RE = re.compile(r"(?:/Users/|~/)[^\n\r\t\"'`<>|*?\\]*?\.(?:md|markdown|txt)(?![A-Za-z0-9_])")
- FILE_EXTS = (".md", ".markdown", ".txt")
- # 不同步的位置:Agent 自己的配置和记录、本工具、临时目录、客户资料暂存、私密目录
- SKIP_PREFIXES = [os.path.join(HOME, d) for d in (
- ".claude", ".codex", ".workbuddy", ".grok", ".agents", ".gemini", ".cursor", ".dondon-sync",
- "dondon-kb-staging", "Downloads",
- )]
- SKIP_PARTS = {".git", "node_modules", "private", ".private", "evals", ".obsidian", ".trash", "build", "dist",
- "skills", "vendor", "__pycache__"}
- SKIP_NAMES = {"SKILL.md", "AGENTS.md", "CLAUDE.md", "CODEBUDDY.md", "GEMINI.md", "MEMORY.md", "SOURCE_OF_TRUTH.md"}
- MAX_FILE_BYTES = 1024 * 1024 # 单个文件超过 1 MB 不传
- MAX_TOTAL_BYTES = 20 * 1024 * 1024 # 一次最多 20 MB
- MAX_FILES = 400
- def walk_strings(v, depth=0):
- if depth > 12:
- return
- if isinstance(v, str):
- yield v
- elif isinstance(v, dict):
- for x in v.values():
- yield from walk_strings(x, depth + 1)
- elif isinstance(v, list):
- for x in v:
- yield from walk_strings(x, depth + 1)
- def note_refs(refs, value, ts, source, title):
- """在工具调用参数和用户的话里找本机文档路径,记下次数、最近时间和来自哪个会话。"""
- if refs is None or value is None:
- return
- if isinstance(value, str):
- try:
- value = json.loads(value)
- except ValueError:
- pass
- for s in walk_strings(value):
- if "/Users/" not in s and "~/" not in s:
- continue
- for m in PATH_RE.finditer(s):
- p = os.path.normpath(os.path.expanduser(m.group(0)))
- r = refs.setdefault(p, {"count": 0, "last": ts, "from": set()})
- r["count"] += 1
- if ts > r["last"]:
- r["last"] = ts
- r["from"].add(f"{source}|{title}" if title else source)
- def skip_reason(p):
- if not p.startswith(HOME + os.sep) or not p.lower().endswith(FILE_EXTS):
- return "不在本人目录或不是文档"
- if any(p == d or p.startswith(d + os.sep) for d in SKIP_PREFIXES):
- return "Agent 配置或暂存目录"
- if p.startswith(os.path.join(HOME, "Library") + os.sep) and not p.startswith(ICLOUD + os.sep):
- return "系统目录"
- parts = os.path.relpath(p, HOME).split(os.sep)
- if any(x in SKIP_PARTS or (x.startswith(".") and x not in (".",)) for x in parts[:-1]):
- return "私密、隐藏或生成目录"
- if parts[-1] in SKIP_NAMES or parts[-1].startswith("."):
- return "Agent 规则文件"
- if SECRET_NAME_RE.search(parts[-1]):
- return SECRET_REASON
- return None
- SECRET_REASON = "像是存密钥、密码的文档,整份不传"
- def remote_rel(p):
- """本机路径 → 同步目录里的相对路径:去掉主目录、iCloud 前缀和「claude code/」。"""
- rel = os.path.relpath(p, ICLOUD) if p.startswith(ICLOUD + os.sep) else os.path.relpath(p, HOME)
- if rel.startswith("claude code" + os.sep):
- rel = rel[len("claude code" + os.sep):]
- return rel
- def pick_files(refs):
- """按最近用到的时间排序,过滤后在数量和总量上限内取文件。含核心秘密的整份不取,名字记进 held。"""
- picked, skipped, total, held = [], {}, 0, []
- for p, r in sorted(refs.items(), key=lambda kv: (kv[1]["last"], kv[1]["count"]), reverse=True):
- why = skip_reason(p)
- if not why and not os.path.isfile(p):
- why = "文件已不在"
- if not why:
- size = os.path.getsize(p)
- if size > MAX_FILE_BYTES:
- why = "单个文件超过 1 MB"
- elif total + size > MAX_TOTAL_BYTES or len(picked) >= MAX_FILES:
- why = "超出 20 MB 或 400 个文件的上限"
- else:
- try:
- with open(p, encoding="utf-8") as fh:
- if secret_hit(fh.read()):
- why = SECRET_REASON
- except (OSError, UnicodeDecodeError):
- why = "读不出来"
- if why == SECRET_REASON:
- held.append(remote_rel(p))
- if why:
- skipped[why] = skipped.get(why, 0) + 1
- continue
- total += size
- picked.append({"path": p, "rel": remote_rel(p), "size": size, "count": r["count"],
- "last": r["last"].isoformat(), "from": sorted(r["from"])[:3]})
- return picked, skipped, total, held
- def load_state():
- try:
- with open(STATE_FILE, encoding="utf-8") as f:
- return json.load(f)
- except (OSError, ValueError):
- return {}
- def save_private(path, text):
- os.makedirs(STATE_DIR, mode=0o700, exist_ok=True)
- fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
- with os.fdopen(fd, "w", encoding="utf-8") as f:
- f.write(text)
- def local(ts):
- return ts.astimezone().strftime("%m-%d %H:%M")
- def render_turn(t, answer_limit):
- out = f"- 用户({local(t['time'])}):{redact(clip(t['user'], USER_MSG_LIMIT))}"
- if t["answer"]:
- out += f"\n 回答:{redact(clip(t['answer'], answer_limit))}"
- return out
- def render_session(s, budget):
- """每个会话一份篇幅:第一轮(交代任务)必留,其余从最近一轮往前放,放不下的中间轮次略去。"""
- turns = s["turns"]
- first, last = turns[0]["time"], turns[-1]["time"]
- head = f"## {'【上次同步以后有新进展】' if s.get('new') and s.get('mark_new') else ''}{s['source']}|{s['project']}"
- if s["title"]:
- head += f"|{s['title']}"
- head += f"\n时间:{local(first)} 至 {local(last)},共 {len(turns)} 轮\n"
- answer_limit = ANSWER_LIMIT if len(turns) <= 3 else ANSWER_LIMIT // 2
- opening = render_turn(turns[0], answer_limit)
- used = len(head) + len(opening)
- recent = []
- for t in reversed(turns[1:]):
- line = render_turn(t, answer_limit)
- if used + len(line) > budget:
- break
- recent.append(line)
- used += len(line)
- skipped = len(turns) - 1 - len(recent)
- body = [opening] + ([f"- ……(中间 {skipped} 轮略去)"] if skipped else []) + list(reversed(recent))
- return head + "\n" + "\n".join(body) + "\n"
- def cmd_collect(args):
- now = datetime.now(timezone.utc)
- state = load_state()
- # 范围固定,不从上次同步算起:聊天看最近 7 天写近况,文档取最近 14 天(整批替换,少了就会把前几天的清掉)。
- # 上次同步的时间只用来标出哪些会话有新进展、自动同步时判断有没有新东西。
- days = min(args.days, MAX_DAYS) if args.days else DEFAULT_DAYS
- since = now - timedelta(days=days)
- files_since = now - timedelta(days=max(days, FILE_DAYS))
- last_sync = parse_time(state["last_sync"]) if state.get("last_sync") else None
- sessions, refs = [], {}
- readers = {"claude": claude_sessions, "codex": codex_sessions, "workbuddy": workbuddy_sessions, "grok": grok_sessions}
- for name in args.sources:
- if name in readers:
- sessions += list(readers[name](files_since, refs))
- # 写近况只用最近 days 天的轮次
- for x in sessions:
- x["turns"] = [t for t in x["turns"] if t["time"] >= since]
- sessions = [x for x in sessions if x["turns"]]
- for x in sessions:
- x["new"] = last_sync is None or x["turns"][-1]["time"] > last_sync
- if args.exclude:
- refs = {p: r for p, r in refs.items() if not any(x in p for x in args.exclude)}
- files, skipped, total, held = pick_files(refs)
- save_private(FILES_LIST, json.dumps({"since": files_since.isoformat(), "files": files, "held_back": held}, ensure_ascii=False))
- if args.exclude:
- sessions = [s for s in sessions if not any(x in s["project"] for x in args.exclude)]
- # 最近的会话优先;超出字数上限时丢掉最旧的会话
- sessions.sort(key=lambda s: s["turns"][-1]["time"], reverse=True)
- # 分出去的旁支会话会带上主会话的历史,同一轮只留第一次出现的那份
- seen, unique = set(), []
- for s in sessions:
- turns = []
- for t in s["turns"]:
- key = (t["time"].replace(microsecond=0), t["user"][:80])
- if key not in seen:
- seen.add(key)
- turns.append(t)
- if turns:
- s["turns"] = turns
- unique.append(s)
- sessions = unique
- # 每个会话分到同样的篇幅(至少 SESSION_MIN_BUDGET),总量超了就丢掉最旧的会话
- for x in sessions:
- x["mark_new"] = last_sync is not None
- budget = max(SESSION_MIN_BUDGET, args.max_chars // max(len(sessions), 1))
- blocks, used, dropped = [], 0, 0
- for s in sessions:
- block = render_session(s, budget)
- if used + len(block) > args.max_chars:
- dropped += 1
- continue
- blocks.append(block)
- used += len(block)
- sources = sorted({s["source"] for s in sessions})
- header = [
- "# 近况素材(只在本机使用,写完近况后会删除)",
- "",
- f"范围:{since.astimezone().strftime('%Y-%m-%d %H:%M')} 至 {now.astimezone().strftime('%Y-%m-%d %H:%M')}(最近 {days} 天)"
- + (f";上次同步 {local(last_sync)},标「上次同步以后有新进展」的会话写近况时放在前面" if last_sync else ""),
- f"来源:{'、'.join(sources) if sources else '无'};会话 {len(sessions)} 个,收入 {len(blocks)} 个,"
- f"因字数上限略去较旧的 {dropped} 个",
- "已隐去:密钥、令牌、密码、长串编码、邮箱、手机号、证件号、银行卡号;代码块已略去。"
- "近况和机会清单里不写任何密钥、密码、账号。",
- "",
- ]
- by_proj = {}
- for f in files:
- top = f["rel"].split(os.sep)[0] if os.sep in f["rel"] else "其他"
- by_proj[top] = by_proj.get(top, 0) + 1
- flist = ["", f"# 最近 {max(days, FILE_DAYS)} 天用到的文档({len(files)} 个,共 {total / 1024 / 1024:.1f} MB,确认后会同步给 bot)", ""]
- flist += [f"- {f['rel']}({local(datetime.fromisoformat(f['last']))},用到 {f['count']} 次)" for f in files[:60]]
- if len(files) > 60:
- flist.append(f"- ……另外 {len(files) - 60} 个")
- save_private(MATERIAL_FILE, "\n".join(header) + "\n".join(blocks) + "\n".join(flist) + "\n")
- print(json.dumps({
- "material": MATERIAL_FILE,
- "since": since.astimezone().strftime("%Y-%m-%d"),
- "files_since": files_since.astimezone().strftime("%Y-%m-%d"),
- "sessions_new_since_last_sync": sum(1 for x in sessions if x["new"]),
- "until": now.astimezone().strftime("%Y-%m-%d"),
- "sources": sources,
- "sessions_found": len(sessions),
- "sessions_included": len(blocks),
- "sessions_dropped": dropped,
- "chars": used,
- "files": len(files),
- "files_mb": round(total / 1024 / 1024, 2),
- "files_by_folder": dict(sorted(by_proj.items(), key=lambda kv: -kv[1])[:10]),
- "files_skipped": skipped,
- "held_back_secret_files": held[:20],
- }, ensure_ascii=False))
- return {"sessions": len(blocks), "new": sum(1 for x in sessions if x["new"]), "files": len(files),
- "since": since, "until": now, "sources": sources}
- def cmd_copy(_args):
- text = sys.stdin.read().strip()
- if not text.startswith(SYNC_MARK):
- sys.exit(f"近况第一行必须是「{SYNC_MARK}」,没有复制。")
- for cmd in (["pbcopy"], ["clip"], ["wl-copy"], ["xclip", "-selection", "clipboard"], ["xsel", "--clipboard", "--input"]):
- if shutil.which(cmd[0]):
- # pbcopy 按系统区域设置解码,没设 UTF-8 时中文会变成乱码
- env = dict(os.environ, LANG="en_US.UTF-8", LC_ALL="en_US.UTF-8")
- subprocess.run(cmd, input=text.encode("utf-8"), check=True, env=env)
- print(f"已复制到剪贴板({len(text)} 字)。")
- return
- sys.exit("这台电脑上没找到剪贴板命令,请手动复制近况全文。")
- def cmd_mark_synced(_args):
- state = load_state()
- state["last_sync"] = datetime.now(timezone.utc).isoformat()
- save_private(STATE_FILE, json.dumps(state, ensure_ascii=False))
- for f in (MATERIAL_FILE, FILES_LIST):
- if os.path.exists(f):
- os.remove(f)
- print(f"已记下同步时间 {datetime.now().strftime('%Y-%m-%d %H:%M')},素材和文件清单已删除。")
- 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
- CA_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "dondon-ca.pem") # 只认这张证书
- KEY_RE = re.compile(r"dds_[A-Za-z0-9_-]{20,}")
- SERVER_RE = re.compile(r"https://[0-9A-Za-z.-]+(?::\d{2,5})?|http://127\.0\.0\.1:\d{2,5}")
- def load_config():
- try:
- with open(CONFIG_FILE, encoding="utf-8") as f:
- cfg = json.load(f)
- except (OSError, ValueError):
- return None
- if cfg.get("key"):
- if not KEY_RE.fullmatch(str(cfg["key"])) or not SERVER_RE.fullmatch(str(cfg.get("server", ""))):
- sys.exit(f"{CONFIG_FILE} 里的同步钥匙或服务器地址不合规,请对 bot 说「绑定电脑」重新配对。")
- return cfg
- return None # 没有同步钥匙就当没配对
- def api(cfg, method, path, body=None, key=None, timeout=60):
- """调同步入口:https 只认 Skill 自带的 dondon-ca.pem;http 只允许 127.0.0.1(本机测试用)"""
- server = cfg["server"]
- ctx = None
- if server.startswith("https://"):
- if not os.path.isfile(CA_FILE):
- sys.exit("Skill 里缺少 dondon-ca.pem,没法安全连接,请更新这个 Skill。")
- ctx = ssl.create_default_context(cafile=CA_FILE)
- data = json.dumps(body, ensure_ascii=False).encode("utf-8") if body is not None else None
- headers = {"content-type": "application/json"}
- if key:
- headers["authorization"] = f"Bearer {key}"
- req = urllib.request.Request(server + path, data=data, method=method, headers=headers)
- # 直连,不走本机的网络代理:代理会替服务器「接通」端口,真正连不上时只剩一句看不懂的握手失败
- opener = urllib.request.build_opener(urllib.request.ProxyHandler({}), urllib.request.HTTPSHandler(context=ctx))
- try:
- with opener.open(req, timeout=timeout) as r:
- return r.status, json.loads(r.read().decode("utf-8") or "{}")
- except urllib.error.HTTPError as e:
- try:
- return e.code, json.loads(e.read().decode("utf-8") or "{}")
- except ValueError:
- return e.code, {}
- except (urllib.error.URLError, OSError, ValueError) as e:
- sys.exit(f"连不上同步服务({getattr(e, 'reason', e)})。多半是同步服务的端口还没对外开放,或者这台电脑的网络"
- f"(公司网络、代理软件的全局或 TUN 模式)拦住了 {server.split('://')[-1]};"
- "换个网络或把这个地址设成直连再试。一直不行就告诉 dondon 的服务方。")
- def err_msg(j):
- return ((j or {}).get("error") or {}).get("message") or "未知原因"
- def cmd_pair(args):
- code = re.sub(r"\D", "", args.code or "")
- if len(code) != 6:
- sys.exit("配对码是 6 位数字。请在微信或飞书里对 dondon 说「绑定电脑」拿一个。")
- server = args.server or DEFAULT_SERVER
- if not SERVER_RE.fullmatch(server):
- sys.exit("服务器地址不合规。")
- st, j = api({"server": server}, "POST", "/sync/claim", {"code": code, "device": socket.gethostname()[:40]})
- if st != 200 or not KEY_RE.fullmatch(str(j.get("key", ""))):
- sys.exit(f"配对没成功:{err_msg(j)}")
- save_private(CONFIG_FILE, json.dumps({"server": server, "key": j["key"], "customer": j.get("customer", "")}, ensure_ascii=False))
- print(json.dumps({"paired": True, "customer": j.get("customer", ""), "server": server}, ensure_ascii=False))
- def stage_files(files):
- """把文档隐去敏感信息后放进暂存目录,并写 INDEX.md。原文件不动。"""
- shutil.rmtree(STAGE_DIR, ignore_errors=True)
- dest = os.path.join(STAGE_DIR, REMOTE_DIR_NAME)
- os.makedirs(dest, mode=0o700)
- rows, hidden, unreadable = [], 0, 0
- for f in files:
- try:
- with open(f["path"], encoding="utf-8") as fh:
- text = fh.read()
- except (OSError, UnicodeDecodeError):
- unreadable += 1
- continue
- if secret_hit(text): # 整理之后才写进密钥的,照样整份不传
- unreadable += 1
- continue
- clean = redact(text)
- if clean != text:
- hidden += 1
- out = os.path.join(dest, f["rel"])
- os.makedirs(os.path.dirname(out), exist_ok=True)
- with open(out, "w", encoding="utf-8") as fh:
- fh.write(clean)
- rows.append(f)
- by_top = {}
- for f in rows:
- by_top.setdefault(f["rel"].split(os.sep)[0] if os.sep in f["rel"] else "其他", []).append(f)
- lines = [
- f"# {REMOTE_DIR_NAME}",
- "",
- OWNER_LINE,
- "",
- f"由客户本机的「同步给 dondon」按最近各个 Agent 聊天里读过、写过的文档整理,同步时间 "
- f"{datetime.now().strftime('%Y-%m-%d %H:%M')}。每次同步整目录替换;这里没有的文件说明最近没再用到。"
- "文件里出现「〔已隐去〕」的地方是本机先隐去的密钥、手机号等。",
- "",
- ]
- for top in sorted(by_top, key=lambda t: -len(by_top[t])):
- lines += [f"## {top}({len(by_top[top])} 个)", ""]
- for f in sorted(by_top[top], key=lambda x: x["last"], reverse=True):
- lines.append(f"- `{f['rel']}`:最近用到 {local(datetime.fromisoformat(f['last']))},"
- f"{f['count']} 次,来自 {'、'.join(f['from'])}")
- lines.append("")
- with open(os.path.join(dest, "INDEX.md"), "w", encoding="utf-8") as fh:
- fh.write("\n".join(lines))
- return dest, len(rows), hidden, unreadable
- HISTORY_DIR = os.path.join(STATE_DIR, "history")
- HISTORY_KEEP = 30
- def read_opps(args):
- if not getattr(args, "opps_file", None):
- return ""
- with open(args.opps_file, encoding="utf-8") as fh:
- return redact(fh.read().strip())
- def save_history(recent, opps, files, result, material=""):
- """每次发出去的近况、机会清单、文档名(自动同步时还有上传的会话素材)在本机留一份,最多留 HISTORY_KEEP 次,用户随时可以翻看。"""
- os.makedirs(HISTORY_DIR, mode=0o700, exist_ok=True)
- name = datetime.now().strftime("%Y%m%d-%H%M%S") + ".md"
- lines = [f"# 同步记录 {datetime.now().strftime('%Y-%m-%d %H:%M')}", "",
- f"结果:{json.dumps(result, ensure_ascii=False)}", "", recent or "(这次没有近况)", "", opps or "(这次没有机会清单)",
- "", f"## 发出的文档({len(files)} 个,内容里的手机号等已隐去)", ""]
- lines += [f"- {f['rel']}" for f in files]
- if material:
- lines += ["", "## 上传的会话素材(自动同步时由服务器据此写近况,写完即丢弃)", "", material]
- save_private(os.path.join(HISTORY_DIR, name), "\n".join(lines) + "\n")
- old = sorted(x for x in os.listdir(HISTORY_DIR) if x.endswith(".md"))
- for x in old[:-HISTORY_KEEP]:
- os.remove(os.path.join(HISTORY_DIR, x))
- def push_key(cfg, args, recent, files, material="", rules=""):
- """上传文档和近况、机会清单;自动同步时不带近况,改交会话素材和写法规则,由服务器写近况和机会清单。"""
- dest, n, hidden, unreadable = stage_files(files)
- up = []
- for dp, _, fns in os.walk(dest):
- for fn in fns:
- full = os.path.join(dp, fn)
- with open(full, encoding="utf-8") as fh:
- up.append({"path": os.path.relpath(full, dest), "text": fh.read()})
- if material:
- opps = ""
- body = {"files": up, "material": material, "rules": rules}
- else:
- opps = read_opps(args)
- body = {"files": up, "recent": recent, "opps": opps}
- st, j = api(cfg, "POST", "/sync/upload", body, key=cfg["key"], timeout=420 if material else 180) # 服务器写近况要一两分钟
- shutil.rmtree(STAGE_DIR, ignore_errors=True)
- if st != 200:
- sys.exit(f"上传没成功:{err_msg(j)}")
- if material:
- recent, opps = j.get("recent") or "", j.get("opps") or ""
- if not recent.startswith(SYNC_MARK):
- sys.exit("同步服务还不支持替你写近况(服务方还没升级),这次没发。")
- result = {"uploaded_files": n, "redacted_files": hidden, "unreadable_skipped": unreadable}
- for _ in range(45): # 服务器每 15 秒处理一次,最多等 90 秒
- time.sleep(2)
- st, r = api(cfg, "GET", "/sync/result", key=cfg["key"])
- if st == 200 and r.get("status") == "done":
- result.update({k: r[k] for k in ("ok", "files", "recent", "opps", "message") if k in r})
- break
- else:
- result["note"] = "已经上传,bot 那边还在处理,几分钟内会收到。"
- save_history(recent, opps, files, result, material)
- print(json.dumps(result, ensure_ascii=False))
- if result.get("ok") is False:
- sys.exit(1)
- def cmd_push(args):
- cfg = load_config()
- if not cfg:
- sys.exit("这台电脑还没和 dondon 配对。请在微信或飞书里对 dondon 说「绑定电脑」,拿到配对码后运行 pair <配对码>。")
- recent = redact(sys.stdin.read().strip()) if args.recent else ""
- if args.recent and not recent.startswith(SYNC_MARK):
- sys.exit(f"近况第一行必须是「{SYNC_MARK}」,没有推送。")
- try:
- with open(FILES_LIST, encoding="utf-8") as f:
- files = json.load(f)["files"]
- except (OSError, ValueError, KeyError):
- sys.exit("没有文件清单,先运行 collect。")
- return push_key(cfg, args, recent, files)
- def fetch_skills():
- """从 bot 取它装着的技能列表(中文名(英文名)),写机会清单时只能从这里选。"""
- cfg = load_config()
- if not cfg:
- sys.exit("这台电脑还没和 dondon 配对,取不到 bot 的技能列表;机会清单可以不写。")
- st, j = api(cfg, "GET", "/sync/skills", key=cfg["key"])
- if st != 200:
- sys.exit(f"取技能列表失败:{err_msg(j)}")
- skills = j.get("skills") or {}
- if not skills:
- sys.exit("bot 那边还没报上技能列表(几分钟后再试);这次机会清单的技能都写「无」。")
- return "\n".join(f"{zh}({en})" for en, zh in skills.items())
- def cmd_skills(_args):
- print(fetch_skills())
- def cmd_status(_args):
- state = load_state()
- print(json.dumps({
- "last_sync": state.get("last_sync"),
- "claude_code_logs": len(glob.glob(CLAUDE_GLOB)),
- "codex_logs": len(glob.glob(CODEX_GLOB, recursive=True)),
- "workbuddy_logs": len(glob.glob(WORKBUDDY_GLOB)),
- "grok_logs": len(glob.glob(GROK_GLOB)),
- "material_left": os.path.exists(MATERIAL_FILE),
- "push_target": {k: v for k, v in (load_config() or {}).items() if k != "key"} or None, # 钥匙不打印
- "auto": schedule_info(state),
- }, ensure_ascii=False))
- # ---------- 自动同步(macOS launchd) ----------
- LABEL = "com.dontbesilent.dondon-sync"
- PLIST = os.path.expanduser(f"~/Library/LaunchAgents/{LABEL}.plist")
- AUTO_LOG = os.path.join(STATE_DIR, "auto.log")
- SKILL_FILE = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "SKILL.md")
- def schedule_info(state=None):
- state = state if state is not None else load_state()
- a = state.get("auto") or {}
- return {"asked": bool(a.get("asked")), "on": bool(a.get("on")) and os.path.exists(PLIST), "time": a.get("time"),
- "last_run": a.get("last_run"), "last_result": a.get("last_result"),
- "history_dir": HISTORY_DIR}
- def save_auto(**kw):
- state = load_state()
- state.setdefault("auto", {}).update(kw)
- save_private(STATE_FILE, json.dumps(state, ensure_ascii=False))
- def launchctl(*a):
- return subprocess.run(["launchctl", *a], capture_output=True, text=True)
- def cmd_schedule(args):
- if args.action == "status":
- print(json.dumps(schedule_info(), ensure_ascii=False))
- return
- if args.action == "decline":
- save_auto(asked=True, on=False)
- print(json.dumps({"auto": "off", "note": "已记下:只手动同步,以后不再问。想开时说「开启自动同步」。"}, ensure_ascii=False))
- return
- uid = str(os.getuid())
- if args.action == "off":
- launchctl("bootout", f"gui/{uid}/{LABEL}")
- if os.path.exists(PLIST):
- os.remove(PLIST)
- save_auto(asked=True, on=False)
- print(json.dumps({"auto": "off", "note": "已停止自动同步。"}, ensure_ascii=False))
- return
- # on
- if sys.platform != "darwin":
- sys.exit("这台电脑不是 macOS,暂时不支持自动同步;每次手动运行同步就行。")
- if not load_config():
- sys.exit("这台电脑还没和 dondon 配对,先对 bot 说「绑定电脑」配对,再开自动同步。")
- m = re.fullmatch(r"([01]?\d|2[0-3]):([0-5]\d)", args.time or "09:00")
- if not m:
- sys.exit("时间写成 HH:MM,例如 09:00。")
- hour, minute = int(m.group(1)), int(m.group(2))
- script = os.path.abspath(__file__)
- path_env = "/usr/bin:/bin:/usr/sbin:/sbin"
- import plistlib
- os.makedirs(os.path.dirname(PLIST), exist_ok=True)
- with open(PLIST, "wb") as f:
- plistlib.dump({
- "Label": LABEL,
- "ProgramArguments": [sys.executable, "-I", script, "auto-run"],
- "StartCalendarInterval": {"Hour": hour, "Minute": minute}, # 那时在睡眠,醒来后补跑一次
- "EnvironmentVariables": {"PATH": path_env, "HOME": HOME, "LANG": "zh_CN.UTF-8"},
- "StandardOutPath": AUTO_LOG, "StandardErrorPath": AUTO_LOG,
- "ProcessType": "Background", "LowPriorityIO": True,
- }, f)
- launchctl("bootout", f"gui/{uid}/{LABEL}")
- r = launchctl("bootstrap", f"gui/{uid}", PLIST)
- if r.returncode:
- sys.exit("登记定时任务失败:" + (r.stderr or r.stdout).strip()[-300:])
- save_auto(asked=True, on=True, time=f"{hour:02d}:{minute:02d}")
- print(json.dumps({"auto": "on", "time": f"每天 {hour:02d}:{minute:02d}",
- "history_dir": HISTORY_DIR, "log": AUTO_LOG}, ensure_ascii=False))
- def skill_rules():
- """从 SKILL.md 取写近况和机会清单的规则(第 2 步、第 2b 步),自动同步时原样交给服务器,按它写近况。"""
- try:
- text = open(SKILL_FILE, encoding="utf-8").read()
- except OSError:
- sys.exit("找不到 SKILL.md,自动同步没法按规则写近况。")
- a, b = text.find("## 第 2 步"), text.find("## 第 3 步")
- if a < 0 or b < a:
- sys.exit("SKILL.md 里找不到第 2 步的规则。")
- return text[a:b]
- def cmd_auto_run(_args):
- """定时任务入口。没人看着:任何一步不对就停下记日志,不发半截内容。"""
- started = datetime.now()
- def done(ok, msg):
- save_auto(last_run=started.strftime("%Y-%m-%d %H:%M"), last_result=("成功:" if ok else "没发出:") + msg)
- print(f"[{started:%Y-%m-%d %H:%M}] {'成功' if ok else '没发出'}:{msg}", flush=True)
- if not ok:
- sys.exit(1)
- if not load_config():
- done(False, "这台电脑还没配对")
- cfg = load_config()
- ns = argparse.Namespace(days=None, sources=["claude", "codex", "workbuddy", "grok"], exclude=[], max_chars=DEFAULT_MAX_CHARS)
- import contextlib
- import io
- with contextlib.redirect_stdout(io.StringIO()):
- info = cmd_collect(ns)
- if not info["sessions"] or not info["new"]:
- for f in (MATERIAL_FILE, FILES_LIST):
- if os.path.exists(f):
- os.remove(f)
- done(True, "上次同步以后没有新的聊天,这次不发")
- material = open(MATERIAL_FILE, encoding="utf-8").read()
- try:
- with open(FILES_LIST, encoding="utf-8") as f:
- files = json.load(f)["files"]
- except (OSError, ValueError, KeyError):
- done(False, "没有文件清单")
- buf = io.StringIO()
- try:
- with contextlib.redirect_stdout(buf):
- push_key(cfg, argparse.Namespace(opps_file=None), "", files, material=redact(material), rules=skill_rules())
- pushed = True
- except SystemExit as e:
- pushed, reason = False, str(e) or buf.getvalue()[-300:]
- if not pushed:
- done(False, "推送失败:" + reason)
- with contextlib.redirect_stdout(io.StringIO()):
- cmd_mark_synced(None)
- done(True, f"近况和 {info['files']} 个文档已同步(近况由服务器按素材写);发出的内容留在 {HISTORY_DIR}")
- def main():
- ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
- sub = ap.add_subparsers(dest="cmd", required=True)
- c = sub.add_parser("collect", help="整理素材")
- c.add_argument("--days", type=int, help=f"聊天看最近 N 天(默认 {DEFAULT_DAYS},最多 {MAX_DAYS});文档取 N 天和 {FILE_DAYS} 天里较长的")
- c.add_argument("--sources", default="claude,codex,workbuddy,grok", help="claude、codex、workbuddy、grok,用逗号隔开")
- c.add_argument("--exclude", nargs="*", default=[], help="不收入的项目目录名(包含即排除)")
- c.add_argument("--max-chars", type=int, default=DEFAULT_MAX_CHARS)
- sub.add_parser("copy", help="从标准输入复制近况到剪贴板")
- sub.add_parser("mark-synced", help="记下同步时间并删除素材")
- sub.add_parser("status", help="查看同步状态")
- pu = sub.add_parser("push", help="把文件清单里的文档(和标准输入里的近况)直接推给 bot")
- pu.add_argument("--recent", action="store_true", help="从标准输入读近况,一起写进 bot")
- pu.add_argument("--opps-file", help="机会清单文件(第一行【机会清单】),一起交给 bot")
- sub.add_parser("skills", help="从 bot 取它装着的技能列表")
- pa = sub.add_parser("pair", help="用 bot 给的 6 位配对码换同步钥匙")
- pa.add_argument("code")
- pa.add_argument("--server", help=f"同步入口(默认 {DEFAULT_SERVER})")
- sc = sub.add_parser("schedule", help="自动同步:on / off / decline / status")
- sc.add_argument("action", choices=["on", "off", "decline", "status"])
- sc.add_argument("--time", help="每天几点同步,HH:MM,默认 09:00")
- sub.add_parser("auto-run", help="定时任务运行的命令(不用手动调用)")
- args = ap.parse_args()
- if args.cmd == "collect":
- args.sources = [x.strip() for x in args.sources.split(",") if x.strip()]
- {"collect": cmd_collect, "copy": cmd_copy, "mark-synced": cmd_mark_synced, "status": cmd_status,
- "push": cmd_push, "skills": cmd_skills, "pair": cmd_pair,
- "schedule": cmd_schedule, "auto-run": cmd_auto_run}[args.cmd](args)
- if __name__ == "__main__":
- main()
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.