deepccc 0.1.3 → 0.1.4

package/dist/cli.js

@@ -12,12 +12,14 @@
  */
 import * as readline from "node:readline";
 import * as process from "node:process";
-import { appendFileSync } from "node:fs";
-import { resolve as resolvePath } from "node:path";
+import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve as resolvePath } from "node:path";
 import { fileURLToPath } from "node:url";
 import { listBuiltinContextSessions } from "./context.js";
 import { resolveBuiltinSession } from "./session-select.js";
 import { createCtrlCState } from "./sigint.js";
+import { buildSkillTemplate } from "./skills.js";
 import { reduceProgress } from "./progress/reducer.js";
 import { TerminalProgressRenderer } from "./progress/terminal-renderer.js";
 import { progressView } from "./progress/view.js";
@@ -526,7 +528,56 @@ async function runRepl(args) {
         process.exit(0);
     });
 }
+/**
+ * skill create 子命令：deepccc skill create <name> [--scope global|project] [--description "..."]
+ * 默认创建为全局技能（~/.deepccc/skills/<name>/SKILL.md，Codex 结构）；
+ * --scope project 创建为项目技能（<cwd>/.deepccc/skills/<name>/SKILL.md）。
+ * 新技能在下一次对话自动生效（技能索引每次 chat() 前重扫）。
+ */
+function runSkillCreate(argv) {
+    const positional = argv.filter((a) => !a.startsWith("--"));
+    const name = positional[0];
+    if (!name) {
+        console.error("usage: deepccc skill create <name> [--scope global|project] [--description \"...\"]");
+        process.exit(1);
+    }
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name)) {
+        console.error(`invalid skill name: ${name}（允许字母/数字/._-，不能以 . 或 - 开头）`);
+        process.exit(1);
+    }
+    const scopeIdx = argv.indexOf("--scope");
+    const scope = scopeIdx !== -1 && argv[scopeIdx + 1] === "project" ? "project" : "global";
+    const descIdx = argv.indexOf("--description");
+    const description = descIdx !== -1 ? (argv[descIdx + 1] ?? "") : "";
+    const base = scope === "project"
+        ? join(process.cwd(), ".deepccc", "skills")
+        : join(homedir(), ".deepccc", "skills");
+    const skillPath = join(base, name, "SKILL.md");
+    if (existsSync(skillPath)) {
+        console.error(`skill already exists: ${skillPath}`);
+        process.exit(1);
+    }
+    try {
+        mkdirSync(join(base, name), { recursive: true });
+        writeFileSync(skillPath, buildSkillTemplate(name, description), "utf8");
+    }
+    catch (err) {
+        console.error(`failed to create skill: ${err.message}`);
+        process.exit(1);
+    }
+    console.log(`created skill: ${skillPath}`);
+    console.log(`scope: ${scope === "project" ? "project（仅当前项目生效）" : "global（所有项目生效）"}`);
+    if (description)
+        console.log(`description: ${description}`);
+    console.log("hot reload: 下一次对话自动生效，无需重启");
+}
 async function main() {
+    // skill create 子命令：deepccc skill create <name> [--scope global|project] [--description "..."]
+    // 默认创建在全局 ~/.deepccc/skills（Codex 目录结构），--scope project 创建到 <cwd>/.deepccc/skills。
+    if (process.argv[2] === "skill" && process.argv[3] === "create") {
+        runSkillCreate(process.argv.slice(4));
+        return;
+    }
     const args = parseArgs();
     if (args.streamJson) {
         const code = await runStreamJson(args);

package/dist/index.d.ts

@@ -35,8 +35,9 @@ export interface ChatSessionOptions {
     /** Optional tool-step limit. Leave unset for no step limit. */
     maxSteps?: number;
     /**
-     * Codex-style skill directories (<dir>/<name>/SKILL.md).
-     * Defaults to ~/.codex/skills, ~/.agents/skills, <cwd>/.codex/skills.
+     * Custom skill directories (<dir>/<name>/SKILL.md). When set, these are
+     * scanned with the highest priority (deepccc source). Defaults to the
+     * combined Claude/Codex/Cursor/DeepCCC directories (see buildDefaultSkillDirs).
      */
     skillsDirs?: string[];
     /**
@@ -87,13 +88,18 @@ interface ChatMessage {
 }
 export declare class ChatSession {
     private model;
-    private systemPrompt;
     private cwd;
     private context;
     private maxSteps?;
     private effort;
     private permissionGate;
+    private skillDirs;
+    private customSystemPrompt;
+    /** 最近一次 chat() 使用的 system prompt（供 history 等读取） */
+    private systemPrompt;
     constructor(overrides?: ChatSessionConfig, options?: ChatSessionOptions);
+    /** 组装系统提示词：固定规则 + 项目指令 + 技能索引 + 用户补充 + 运行时上下文 */
+    private buildSystemPrompt;
     chat(userMessage: string, signal?: AbortSignal): AsyncIterable<ChatEvent>;
     /** 返回当前的会话历史（只读） */
     get history(): ReadonlyArray<ChatMessage>;

package/dist/index.js

@@ -12,7 +12,7 @@ import { createRawStreamLog, } from "./raw-stream-log.js";
 import { BuiltinContextManager, buildSummaryPrompt, defaultBuiltinSessionId, } from "./context.js";
 import { createBuiltinFileTools } from "./file-tools.js";
 import { PermissionGate } from "./permissions.js";
-import { buildDefaultSkillDirs, buildSkillsIndexPrompt, scanSkillsDirs } from "./skills.js";
+import { buildDefaultSkillDirs, buildSkillsIndexPrompt, scanSkillsDirs, } from "./skills.js";
 import { applyPrivacy, applyPrivacyToJson } from "./privacy.js";
 // ---------------------------------------------------------------------------
 // 系统提示词 — 编译期冻结常量（DeepCCC 英文品牌）
@@ -82,12 +82,15 @@ function normalizeMaxSteps(value) {
 }
 export class ChatSession {
     model;
-    systemPrompt;
     cwd;
     context;
     maxSteps;
     effort;
     permissionGate;
+    skillDirs;
+    customSystemPrompt;
+    /** 最近一次 chat() 使用的 system prompt（供 history 等读取） */
+    systemPrompt = "";
     constructor(overrides = {}, options = {}) {
         const apiKey = overrides.apiKey ?? appConfig.apiKey;
         if (!apiKey) {
@@ -104,32 +107,38 @@ export class ChatSession {
         this.model = provider(modelId);
         this.cwd = options.cwd ?? process.cwd();
         this.maxSteps = normalizeMaxSteps(options.maxSteps);
-        // 构建系统提示词
+        this.customSystemPrompt = options.systemPrompt ?? "";
+        // 技能目录在构造时确定；技能内容在每次 chat() 前重新扫描（mtime 热加载），
+        // 因此创建/修改技能后下一次对话自动生效，无需重启。
+        this.skillDirs =
+            options.skillsDirs?.map((d) => ({ dir: d, source: "deepccc", scope: "project" })) ??
+                buildDefaultSkillDirs(this.cwd);
+        this.context = new BuiltinContextManager({
+            persist: options.persist ?? false,
+            contextDir: options.contextDir,
+            sessionId: options.sessionId ?? defaultBuiltinSessionId(this.cwd),
+            cwd: this.cwd,
+            compactAtTokens: options.compactAtTokens,
+            keepRecentMessages: options.keepRecentMessages,
+        });
+        this.permissionGate = new PermissionGate(options.permissionMode ?? "ask", options.permissionResolver);
+    }
+    /** 组装系统提示词：固定规则 + 项目指令 + 技能索引 + 用户补充 + 运行时上下文 */
+    buildSystemPrompt(skills) {
         const systemContent = [SYSTEM_PROMPT];
         const projectInstructions = readProjectInstructionFiles(this.cwd);
         if (projectInstructions) {
             systemContent.push("", projectInstructions);
         }
-        // Codex-style skills 索引注入（name + description + 路径，模型按需 read_file 全文）
-        const skills = scanSkillsDirs(options.skillsDirs ?? buildDefaultSkillDirs(this.cwd));
         const skillsPrompt = buildSkillsIndexPrompt(skills);
         if (skillsPrompt) {
             systemContent.push("", skillsPrompt);
         }
-        if (options.systemPrompt) {
-            systemContent.push("", options.systemPrompt);
+        if (this.customSystemPrompt) {
+            systemContent.push("", this.customSystemPrompt);
         }
         systemContent.push("", buildRuntimeWorkspacePrompt(this.cwd));
-        this.systemPrompt = systemContent.join("\n");
-        this.context = new BuiltinContextManager({
-            persist: options.persist ?? false,
-            contextDir: options.contextDir,
-            sessionId: options.sessionId ?? defaultBuiltinSessionId(this.cwd),
-            cwd: this.cwd,
-            compactAtTokens: options.compactAtTokens,
-            keepRecentMessages: options.keepRecentMessages,
-        });
-        this.permissionGate = new PermissionGate(options.permissionMode ?? "ask", options.permissionResolver);
+        return systemContent.join("\n");
     }
     async *chat(userMessage, signal) {
         this.context.appendMessage({ role: "user", content: userMessage });
@@ -159,9 +168,14 @@ export class ChatSession {
             }
             const toolContext = [];
             const maxSteps = this.maxSteps;
+            // 每次对话前重新扫描技能索引（并行 + mtime 缓存，开销极小）：
+            // 新技能/修改的技能在下一次对话自动生效（热加载）。
+            const skills = await scanSkillsDirs(this.skillDirs);
+            const system = this.buildSystemPrompt(skills);
+            this.systemPrompt = system;
             const result = streamText({
                 model: this.model,
-                system: this.systemPrompt,
+                system,
                 messages: this.context.buildModelMessages(),
                 tools: createBuiltinFileTools(this.cwd, { permissionGate: this.permissionGate }),
                 stopWhen: maxSteps !== undefined ? stepCountIs(maxSteps) : isLoopFinished(),

package/dist/skills.d.ts

@@ -1,16 +1,33 @@
 /**
- * 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。
  */
+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 */
 export declare function parseSkillFrontmatter(content: string): {
@@ -18,21 +35,23 @@ export declare function parseSkillFrontmatter(content: string): {
     description: string;
 } | null;
 /**
- * 扫描多个 skill 目录，返回去重后的 skill 列表。
- * 同名 skill 后面的目录覆盖前面的（调用方应把项目级目录放最后）。
- * 隐藏目录（.system 等）和无 SKILL.md 的目录会被跳过。
+ * 扫描多个 skill 目录（并行读取），按 name 去重。
+ * 同名技能：后面的 spec（高优先级）覆盖前面的（低优先级）。
+ * 隐藏目录（.system 等）和无 SKILL.md 的目录会被跳过；缺失目录跳过。
  */
-export declare function scanSkillsDirs(dirs: string[]): BuiltinSkill[];
+export declare function scanSkillsDirs(dirs: SkillDirSpec[]): Promise<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 declare function buildDefaultSkillDirs(cwd: string): string[];
+export declare function buildDefaultSkillDirs(cwd: string): SkillDirSpec[];
 /**
  * 生成 skill 索引提示词（注入 system prompt）。
- * 索引只含 name + description + 路径，并指示模型在任务匹配时
- * 先用 read_file 读取 SKILL.md 全文再执行——这是触发率的关键。
+ * 索引只含 name + description + 来源 + 路径，并指示模型在任务匹配时
+ * 先用 read_file 读取 SKILL.md 全文再执行；同时声明"创建技能"约定
+ * （模型在对话中应把新技能创建到 ~/.deepccc/skills 或项目 .deepccc/skills）。
  */
 export declare function buildSkillsIndexPrompt(skills: BuiltinSkill[]): string;
+/** 生成 Codex 结构的新技能 SKILL.md 模板（供 CLI skill create / 对话创建约定共用） */
+export declare function buildSkillTemplate(name: string, description: string): string;

package/dist/skills.js

@@ -1,12 +1,19 @@
 /**
- * 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";
 /** 解析 SKILL.md frontmatter（兼容 CRLF），返回 name + description；无 frontmatter 返回 null */
@@ -24,72 +31,132 @@ export function parseSkillFrontmatter(content) {
         description: descMatch?.[1].trim() ?? "",
     };
 }
+// ---------------------------------------------------------------------------
+// mtime 热加载缓存：同一进程内重复扫描命中缓存（stat 校验），文件变化自动重读
+// ---------------------------------------------------------------------------
+const skillFileCache = new Map();
+async function readSkillFile(skillPath) {
+    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) {
+export async function scanSkillsDirs(dirs) {
     const byName = new Map();
-    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;
-            try {
-                content = readFileSync(skillPath, "utf-8");
-            }
-            catch {
-                continue; // 没有 SKILL.md 的目录不是 skill
-            }
+        // 目录内所有候选 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(parsed.name, {
-                name: parsed.name,
-                description: parsed.description,
-                skillPath,
+            byName.set(result.name, {
+                name: result.name,
+                description: result.description,
+                skillPath: result.skillPath,
+                source: spec.source,
+                scope: spec.scope,
             });
         }
     }
     return [...byName.values()];
 }
 /**
- * 默认 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) {
+    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) {
     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.skillPath}\`): ${s.description || "(no description)"}`),
+        ...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>",
+        "---",
+        "",
+        "<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, description) {
+    return [
+        "---",
+        `name: ${name}`,
+        `description: ${description}`,
+        "---",
+        "",
+        `# ${name}`,
+        "",
+        "<skill instructions>",
+        "",
+    ].join("\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepccc",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "A lightweight DeepSeek-optimized coding agent with OpenAI-compatible model support.",
   "license": "Apache-2.0",
   "keywords": [