chatccc 0.2.226 → 0.2.227

package/src/builtin/skills.ts

@@ -1,21 +1,41 @@
 /**
- * builtin/skills.ts — Codex-style skills 支持
+ * skills.ts — 多来源技能扫描（DeepCCC 统一入口）
  *
- * 从用户级（~/.codex/skills、~/.agents/skills）和项目级（<cwd>/.codex/skills）
- * 扫描 Codex 目录式 skill（<name>/SKILL.md），解析 frontmatter 中的
- * name + description，生成索引注入 system prompt。模型按需用 read_file
- * 读取 SKILL.md 全文并执行（索引注入省 token，触发靠 description + 指令）。
+ * 并行扫描 Claude / Codex / Cursor / DeepCCC 四套目录式技能
+ * （<name>/SKILL.md + YAML frontmatter，三套生态同构）。
+ *
+ * 同名优先级（高 → 低）：deepccc > codex > cursor > claude；
+ * 同来源内：project（项目级）> global（用户级）。
+ * 目录列表按低 → 高排列，扫描时后者覆盖前者，天然实现优先级。
+ *
+ * 热加载：SKILL.md 内容带 mtime 缓存，文件变化时自动重读；
+ * 目录枚举每次都做（新技能目录立即被发现）。因此"创建技能 →
+ * 下一次对话自动生效"，无需重启，也无需常驻 watcher。
  */
 
-import { readFileSync, readdirSync } from "node:fs";
+import { readdirSync } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
+export type SkillSource = "deepccc" | "codex" | "cursor" | "claude";
+export type SkillScope = "global" | "project";
+
 export interface BuiltinSkill {
   name: string;
   description: string;
   /** SKILL.md 的绝对路径 */
   skillPath: string;
+  /** 来源（优先级 deepccc > codex > cursor > claude） */
+  source: SkillSource;
+  /** global = 用户级；project = 项目级（同来源内 project > global） */
+  scope: SkillScope;
+}
+
+export interface SkillDirSpec {
+  dir: string;
+  source: SkillSource;
+  scope: SkillScope;
 }
 
 /** 解析 SKILL.md frontmatter（兼容 CRLF），返回 name + description；无 frontmatter 返回 null */
@@ -34,41 +54,65 @@ export function parseSkillFrontmatter(
   };
 }
 
+// ---------------------------------------------------------------------------
+// mtime 热加载缓存：同一进程内重复扫描命中缓存（stat 校验），文件变化自动重读
+// ---------------------------------------------------------------------------
+
+const skillFileCache = new Map<string, { mtimeMs: number; content: string }>();
+
+async function readSkillFile(skillPath: string): Promise<string | null> {
+  let st;
+  try {
+    st = await stat(skillPath);
+  } catch {
+    return null;
+  }
+  if (!st.isFile()) return null;
+  const cached = skillFileCache.get(skillPath);
+  if (cached && cached.mtimeMs === st.mtimeMs) return cached.content;
+  const content = await readFile(skillPath, "utf8");
+  skillFileCache.set(skillPath, { mtimeMs: st.mtimeMs, content });
+  return content;
+}
+
 /**
- * 扫描多个 skill 目录，返回去重后的 skill 列表。
- * 同名 skill 后面的目录覆盖前面的（调用方应把项目级目录放最后）。
- * 隐藏目录（.system 等）和无 SKILL.md 的目录会被跳过。
+ * 扫描多个 skill 目录（并行读取），按 name 去重。
+ * 同名技能：后面的 spec（高优先级）覆盖前面的（低优先级）。
+ * 隐藏目录（.system 等）和无 SKILL.md 的目录会被跳过；缺失目录跳过。
  */
-export function scanSkillsDirs(dirs: string[]): BuiltinSkill[] {
+export async function scanSkillsDirs(dirs: SkillDirSpec[]): Promise<BuiltinSkill[]> {
   const byName = new Map<string, BuiltinSkill>();
 
-  for (const dir of dirs) {
+  for (const spec of dirs) {
     let entries;
     try {
-      entries = readdirSync(dir, { withFileTypes: true });
+      entries = readdirSync(spec.dir, { withFileTypes: true });
     } catch {
       continue; // 目录不存在或不可读：跳过
     }
 
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      if (entry.name.startsWith(".")) continue; // 排除 .system 等隐藏/内置目录
-
-      const skillPath = join(dir, entry.name, "SKILL.md");
-      let content: string;
-      try {
-        content = readFileSync(skillPath, "utf-8");
-      } catch {
-        continue; // 没有 SKILL.md 的目录不是 skill
-      }
-
-      const parsed = parseSkillFrontmatter(content);
-      if (!parsed) continue;
-
-      byName.set(parsed.name, {
-        name: parsed.name,
-        description: parsed.description,
-        skillPath,
+    // 目录内所有候选 SKILL.md 并行读取（读文件是扫描的瓶颈）
+    const results = await Promise.all(
+      entries
+        .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+        .map(async (entry) => {
+          const skillPath = join(spec.dir, entry.name, "SKILL.md");
+          const content = await readSkillFile(skillPath);
+          if (content === null) return null;
+          const parsed = parseSkillFrontmatter(content);
+          if (!parsed) return null;
+          return { ...parsed, skillPath };
+        }),
+    );
+
+    for (const result of results) {
+      if (!result) continue;
+      byName.set(result.name, {
+        name: result.name,
+        description: result.description,
+        skillPath: result.skillPath,
+        source: spec.source,
+        scope: spec.scope,
       });
     }
   }
@@ -77,32 +121,70 @@ export function scanSkillsDirs(dirs: string[]): BuiltinSkill[] {
 }
 
 /**
- * 默认 skill 扫描目录：
- * 1. ~/.codex/skills（Codex CLI 旧路径，用户实际在用的地方）
- * 2. ~/.agents/skills（Codex 标准全局目录）
- * 3. <cwd>/.codex/skills（项目级，优先级最高，放最后）
+ * 默认技能扫描目录（按优先级从低到高排列，扫描时后者覆盖前者）：
+ * claude(global→project) < cursor(global→project) < codex(global→project) < deepccc(global→project)
+ * 其中 codex 全局包含 ~/.codex/skills（CLI 旧路径）与 ~/.agents/skills（标准全局目录）。
  */
-export function buildDefaultSkillDirs(cwd: string): string[] {
+export function buildDefaultSkillDirs(cwd: string): SkillDirSpec[] {
+  const h = homedir();
   return [
-    join(homedir(), ".codex", "skills"),
-    join(homedir(), ".agents", "skills"),
-    join(cwd, ".codex", "skills"),
+    { dir: join(h, ".claude", "skills"), source: "claude", scope: "global" },
+    { dir: join(cwd, ".claude", "skills"), source: "claude", scope: "project" },
+    { dir: join(h, ".cursor", "skills"), source: "cursor", scope: "global" },
+    { dir: join(cwd, ".cursor", "skills"), source: "cursor", scope: "project" },
+    { dir: join(h, ".codex", "skills"), source: "codex", scope: "global" },
+    { dir: join(h, ".agents", "skills"), source: "codex", scope: "global" },
+    { dir: join(cwd, ".codex", "skills"), source: "codex", scope: "project" },
+    { dir: join(h, ".deepccc", "skills"), source: "deepccc", scope: "global" },
+    { dir: join(cwd, ".deepccc", "skills"), source: "deepccc", scope: "project" },
   ];
 }
 
 /**
  * 生成 skill 索引提示词（注入 system prompt）。
- * 索引只含 name + description + 路径，并指示模型在任务匹配时
- * 先用 read_file 读取 SKILL.md 全文再执行——这是触发率的关键。
+ * 索引只含 name + description + 来源 + 路径，并指示模型在任务匹配时
+ * 先用 read_file 读取 SKILL.md 全文再执行；同时声明"创建技能"约定
+ * （模型在对话中应把新技能创建到 ~/.deepccc/skills 或项目 .deepccc/skills）。
  */
 export function buildSkillsIndexPrompt(skills: BuiltinSkill[]): string {
   if (skills.length === 0) return "";
 
   const lines = [
-    "## Available Skills (Codex-style)",
-    "The following Codex-style skills are available on this machine. When a user request matches a skill's description, first read its full SKILL.md with read_file, then follow the instructions in it exactly.",
+    "## Available Skills",
+    "Skills are scanned in parallel from Claude/Codex/Cursor/DeepCCC skill directories.",
+    "On name conflicts: DeepCCC > Codex > Cursor > Claude wins; within one source, project scope wins over global.",
+    "When a user request matches a skill's description, first read its full SKILL.md with read_file, then follow the instructions in it exactly.",
+    "",
+    ...skills.map((s) => `- **${s.name}** [${s.source}:${s.scope}] (\`${s.skillPath}\`): ${s.description || "(no description)"}`),
+    "",
+    "## Creating Skills",
+    "When the user asks to create a skill, create it as a Codex-style directory skill at",
+    "~/.deepccc/skills/<name>/SKILL.md (global, default) or <cwd>/.deepccc/skills/<name>/SKILL.md (project, only when the user explicitly asks for a project-scoped skill).",
+    "SKILL.md format:",
+    "```",
+    "---",
+    "name: <skill-name>",
+    "description: <one-line description>",
+    "---",
     "",
-    ...skills.map((s) => `- **${s.name}** (\`${s.skillPath}\`): ${s.description || "(no description)"}`),
+    "<instructions>",
+    "```",
+    "New skills are picked up automatically on the next message (hot reload); no restart is needed.",
   ];
   return lines.join("\n");
 }
+
+/** 生成 Codex 结构的新技能 SKILL.md 模板（供 CLI skill create / 对话创建约定共用） */
+export function buildSkillTemplate(name: string, description: string): string {
+  return [
+    "---",
+    `name: ${name}`,
+    `description: ${description}`,
+    "---",
+    "",
+    `# ${name}`,
+    "",
+    "<skill instructions>",
+    "",
+  ].join("\n");
+}

package/src/card-action-routing.ts

@@ -1,14 +1,14 @@
-export type FeishuCommandChatType = "p2p" | "group";
-
-type SessionRegistryForRouting = Record<string, { chatType?: string }>;
-
-/**
- * Feishu card action callbacks do not include the chat type. Recover it from
- * the persisted binding so buttons clicked in a private chat stay in p2p.
- */
-export function resolveFeishuCardActionChatType(
-  chatId: string,
-  registry: SessionRegistryForRouting,
-): FeishuCommandChatType {
-  return registry[chatId]?.chatType === "p2p" ? "p2p" : "group";
-}
+export type FeishuCommandChatType = "p2p" | "group";
+
+type SessionRegistryForRouting = Record<string, { chatType?: string }>;
+
+/**
+ * Feishu card action callbacks do not include the chat type. Recover it from
+ * the persisted binding so buttons clicked in a private chat stay in p2p.
+ */
+export function resolveFeishuCardActionChatType(
+  chatId: string,
+  registry: SessionRegistryForRouting,
+): FeishuCommandChatType {
+  return registry[chatId]?.chatType === "p2p" ? "p2p" : "group";
+}