deepccc 0.1.4 → 0.1.5

package/README.md

@@ -251,13 +251,29 @@ ChatCCC 是一个把 Claude Code / Codex / Cursor / CCC Agent 聚合到飞书/
 
 这些内容会放在固定系统提示词之后，作为项目指导使用。
 
-## Codex-style Skills 支持
+## Skills 自动加载
 
-`deepccc` 会扫描以下目录，把本机的 Codex 目录式 skill（`<name>/SKILL.md`，含 `name` + `description` frontmatter）索引注入系统提示词；模型在任务匹配时先用 `read_file` 读取 `SKILL.md` 全文再执行：
+`deepccc` 会并行扫描本机 **Claude / Codex / Cursor / DeepCCC** 四套生态的目录式 skill（`<name>/SKILL.md`，含 `name` + `description` frontmatter），把索引注入系统提示词；模型在任务匹配时先用 `read_file` 读取 `SKILL.md` 全文再执行。
 
-- `~/.codex/skills`
-- `~/.agents/skills`
-- `<cwd>/.codex/skills`（项目级，优先级最高）
+自动加载的目录（按优先级从低到高排列，扫描时后者覆盖前者）：
+
+| 目录 | 来源 | 级别 |
+| --- | --- | --- |
+| `~/.claude/skills` | claude | 用户级 |
+| `<cwd>/.claude/skills` | claude | 项目级 |
+| `~/.cursor/skills` | cursor | 用户级 |
+| `<cwd>/.cursor/skills` | cursor | 项目级 |
+| `~/.codex/skills` | codex | 用户级 |
+| `~/.agents/skills` | codex | 用户级（标准全局目录） |
+| `<cwd>/.codex/skills` | codex | 项目级 |
+| `~/.deepccc/skills` | deepccc | 用户级 |
+| `<cwd>/.deepccc/skills` | deepccc | 项目级 |
+
+**同名去重优先级（高 → 低）：`deepccc` > `codex` > `cursor` > `claude`**；同一来源内：**项目级（project）> 用户级（global）**。扫描时低优先级先入索引、高优先级同名覆盖，天然实现优先级。
+
+扫描带 mtime 热加载缓存：SKILL.md 内容变化自动重读，新技能目录每次扫描立即被发现——因此"创建技能 → 下一次对话自动生效"，无需重启。
+
+需要新建技能时，创建为 Codex 结构：`~/.deepccc/skills/<name>/SKILL.md`（默认，全局）或 `<cwd>/.deepccc/skills/<name>/SKILL.md`（`--scope project`，仅当用户明确要求项目级时）。
 
 ## 内置工具
 
@@ -269,6 +285,8 @@ ChatCCC 是一个把 Claude Code / Codex / Cursor / CCC Agent 聚合到飞书/
 - 编辑、创建、删除、移动文件
 - 应用 unified diff patch
 - 运行非交互式 shell 命令，并返回 stdout、stderr、exitCode 和超时状态
+- 联网搜索（`websearch`：DuckDuckGo，免 API key，返回标题 + URL + 摘要）
+- 抓取网页并转纯文本（`webfetch`：仅 http/https，自动去 HTML 标签、控制长度与超时）
 
 命令返回非零退出码时不会直接被当成工具异常；模型可以读取结构化结果，继续判断下一步。
 

package/dist/file-tools.js

@@ -8,6 +8,7 @@ import { createInterface } from "node:readline";
 import { jsonSchema, tool } from "ai";
 import { isDangerousCommand } from "./permissions.js";
 import { killProcessTree } from "./proc-tree-kill.js";
+import { webFetchForTool, webSearchForTool, } from "./web-tools.js";
 const MAX_READ_BYTES = 1024 * 1024;
 const MAX_LIST_ENTRIES = 200;
 const MAX_SEARCH_RESULTS = 100;
@@ -1138,5 +1139,32 @@ export function createBuiltinFileTools(cwd, options = {}) {
                 return applyPatchForTool(cwd, input);
             },
         }),
+        // 联网工具：只读外部网络操作，不触碰本地文件系统，无需权限询问
+        websearch: tool({
+            description: "Search the web (DuckDuckGo, no API key) and return matching titles, URLs, and snippets. Use when you need current or external information not available locally, e.g. latest docs, news, or package versions.",
+            inputSchema: jsonSchema({
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    query: { type: "string", description: "Search query." },
+                    maxResults: { type: "number", description: "Optional result count, default 5, capped at 10." },
+                },
+                required: ["query"],
+            }),
+            execute: (input, options) => webSearchForTool(input, { abortSignal: options.abortSignal }),
+        }),
+        webfetch: tool({
+            description: "Fetch a URL and return its readable text content (HTML stripped, truncated). Use for documentation pages, articles, or API docs. Only http/https URLs are allowed.",
+            inputSchema: jsonSchema({
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    url: { type: "string", description: "http/https URL to fetch." },
+                    maxChars: { type: "number", description: "Optional text length cap, default 10000, capped at 100000." },
+                },
+                required: ["url"],
+            }),
+            execute: (input, options) => webFetchForTool(input, { abortSignal: options.abortSignal }),
+        }),
     };
 }

package/dist/web-tools.d.ts

@@ -0,0 +1,82 @@
+/**
+ * web-tools.ts — websearch / webfetch 内置工具（agent 端联网，业界主流做法）
+ *
+ * 与 Claude Code 的 WebSearch/WebFetch、Codex 的 web search 相同形态：
+ * 模型通过 function calling 调用，agent 进程执行 HTTP 请求，结果回填上下文。
+ * 两者都是只读外部网络操作，不触碰本地文件系统，无需权限询问。
+ *
+ * - websearch：DuckDuckGo HTML 端点（免 API key），返回标题 + URL + 摘要
+ * - webfetch：HTTP GET + HTML 转纯文本，控制大小与超时
+ *
+ * 零新依赖：使用 Node 20 内置 fetch / AbortSignal / Buffer。
+ * 解析逻辑拆成纯函数导出，便于单测；fetch 可通过 options 注入 mock。
+ */
+export interface WebSearchInput {
+    query: string;
+    /** 返回结果条数上限，默认 5，上限 10 */
+    maxResults?: number;
+}
+export interface WebSearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+}
+export interface WebSearchOutput {
+    query: string;
+    results: WebSearchResult[];
+    truncated: boolean;
+    durationMs: number;
+}
+export interface WebFetchInput {
+    url: string;
+    /** 返回纯文本字符数上限，默认 10000，上限 100000 */
+    maxChars?: number;
+}
+export interface WebFetchOutput {
+    url: string;
+    contentType: string;
+    title: string;
+    text: string;
+    chars: number;
+    truncated: boolean;
+    durationMs: number;
+}
+export declare const WEB_SEARCH_TIMEOUT_MS = 15000;
+export declare const WEB_FETCH_TIMEOUT_MS = 20000;
+export declare const WEB_SEARCH_DEFAULT_RESULTS = 5;
+export declare const WEB_SEARCH_MAX_RESULTS = 10;
+export declare const WEB_FETCH_DEFAULT_CHARS = 10000;
+export declare const WEB_FETCH_MAX_CHARS = 100000;
+/** webfetch 读取响应体的大小上限（超出即截断），防止把整个大文件拉进上下文 */
+export declare const WEB_FETCH_MAX_BYTES: number;
+export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export interface WebToolOptions {
+    abortSignal?: AbortSignal;
+    /** 测试注入用，默认全局 fetch */
+    fetchImpl?: FetchLike;
+    timeoutMs?: number;
+}
+/** 提取 <title> 文本（用于 webfetch 结果），无则返回空字符串 */
+export declare function extractHtmlTitle(html: string): string;
+/**
+ * HTML 转纯文本：
+ * 去掉 script/style/noscript/svg/注释 → 块级元素补换行 → 去标签 → 解实体 → 压缩空白。
+ */
+export declare function htmlToPlainText(html: string): string;
+/** 解码 DuckDuckGo 结果链接：/l/?uddg=<encoded> 还原为目标 URL */
+export declare function decodeDdgHref(href: string): string;
+/**
+ * 解析 DuckDuckGo HTML 搜索结果页（html.duckduckgo.com/html）。
+ * 提取 result__a（标题 + href）与 result__snippet（摘要）。
+ */
+export declare function parseDuckDuckGoHtml(html: string): WebSearchResult[];
+/**
+ * websearch：DuckDuckGo HTML 搜索（免 API key），返回标题 + URL + 摘要。
+ * 网络失败抛错（成为 tool-error），搜索无结果返回空数组（不是错误）。
+ */
+export declare function webSearchForTool(input: WebSearchInput, options?: WebToolOptions): Promise<WebSearchOutput>;
+/**
+ * webfetch：HTTP GET + HTML 转纯文本。
+ * 只允许 http/https（防 file:// 等本地协议），非 2xx 抛错。
+ */
+export declare function webFetchForTool(input: WebFetchInput, options?: WebToolOptions): Promise<WebFetchOutput>;

package/dist/web-tools.js

@@ -0,0 +1,246 @@
+/**
+ * web-tools.ts — websearch / webfetch 内置工具（agent 端联网，业界主流做法）
+ *
+ * 与 Claude Code 的 WebSearch/WebFetch、Codex 的 web search 相同形态：
+ * 模型通过 function calling 调用，agent 进程执行 HTTP 请求，结果回填上下文。
+ * 两者都是只读外部网络操作，不触碰本地文件系统，无需权限询问。
+ *
+ * - websearch：DuckDuckGo HTML 端点（免 API key），返回标题 + URL + 摘要
+ * - webfetch：HTTP GET + HTML 转纯文本，控制大小与超时
+ *
+ * 零新依赖：使用 Node 20 内置 fetch / AbortSignal / Buffer。
+ * 解析逻辑拆成纯函数导出，便于单测；fetch 可通过 options 注入 mock。
+ */
+export const WEB_SEARCH_TIMEOUT_MS = 15_000;
+export const WEB_FETCH_TIMEOUT_MS = 20_000;
+export const WEB_SEARCH_DEFAULT_RESULTS = 5;
+export const WEB_SEARCH_MAX_RESULTS = 10;
+export const WEB_FETCH_DEFAULT_CHARS = 10_000;
+export const WEB_FETCH_MAX_CHARS = 100_000;
+/** webfetch 读取响应体的大小上限（超出即截断），防止把整个大文件拉进上下文 */
+export const WEB_FETCH_MAX_BYTES = 512 * 1024;
+const SEARCH_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36";
+function normalizeMaxResults(value) {
+    if (value === undefined)
+        return WEB_SEARCH_DEFAULT_RESULTS;
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error("maxResults must be a positive integer when provided");
+    }
+    return Math.min(value, WEB_SEARCH_MAX_RESULTS);
+}
+function normalizeMaxChars(value) {
+    if (value === undefined)
+        return WEB_FETCH_DEFAULT_CHARS;
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error("maxChars must be a positive integer when provided");
+    }
+    return Math.min(value, WEB_FETCH_MAX_CHARS);
+}
+function buildSignal(timeoutMs, abortSignal) {
+    const signals = [AbortSignal.timeout(timeoutMs)];
+    if (abortSignal)
+        signals.push(abortSignal);
+    return signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+}
+function decodeEntities(s) {
+    return s
+        .replace(/&lt;/gi, "<")
+        .replace(/&gt;/gi, ">")
+        .replace(/&quot;/gi, '"')
+        .replace(/&#0?39;/gi, "'")
+        .replace(/&nbsp;/gi, " ")
+        .replace(/&#(\d+);/g, (_, n) => {
+        try {
+            return String.fromCodePoint(Number(n));
+        }
+        catch {
+            return "";
+        }
+    })
+        .replace(/&#x([0-9a-f]+);/gi, (_, h) => {
+        try {
+            return String.fromCodePoint(parseInt(h, 16));
+        }
+        catch {
+            return "";
+        }
+    })
+        .replace(/&amp;/gi, "&");
+}
+function stripTags(s) {
+    return decodeEntities(s.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim());
+}
+/** 提取 <title> 文本（用于 webfetch 结果），无则返回空字符串 */
+export function extractHtmlTitle(html) {
+    const m = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
+    return m ? stripTags(m[1]) : "";
+}
+/**
+ * HTML 转纯文本：
+ * 去掉 script/style/noscript/svg/注释 → 块级元素补换行 → 去标签 → 解实体 → 压缩空白。
+ */
+export function htmlToPlainText(html) {
+    let text = html
+        .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, " ")
+        .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, " ")
+        .replace(/<noscript\b[^>]*>[\s\S]*?<\/noscript>/gi, " ")
+        .replace(/<svg\b[^>]*>[\s\S]*?<\/svg>/gi, " ")
+        .replace(/<!--[\s\S]*?-->/g, " ")
+        .replace(/<\/(p|div|li|tr|h[1-6]|pre|blockquote|section|article|table|ul|ol|header|footer|nav|dl|dd|dt)>/gi, "\n")
+        .replace(/<(br|hr)\s*\/?>/gi, "\n")
+        .replace(/<[^>]+>/g, "");
+    text = decodeEntities(text);
+    return text
+        .split("\n")
+        .map((line) => line.replace(/\s+/g, " ").trim())
+        .filter((line, i, arr) => line !== "" || (i > 0 && arr[i - 1] !== ""))
+        .join("\n")
+        .trim();
+}
+/** 解码 DuckDuckGo 结果链接：/l/?uddg=<encoded> 还原为目标 URL */
+export function decodeDdgHref(href) {
+    let h = href.trim();
+    if (h.startsWith("//"))
+        h = "https:" + h;
+    try {
+        const u = new URL(h);
+        if (u.hostname === "duckduckgo.com" && u.pathname.startsWith("/l/")) {
+            const uddg = u.searchParams.get("uddg");
+            if (uddg)
+                return decodeURIComponent(uddg);
+        }
+        return u.toString();
+    }
+    catch {
+        return h;
+    }
+}
+/**
+ * 解析 DuckDuckGo HTML 搜索结果页（html.duckduckgo.com/html）。
+ * 提取 result__a（标题 + href）与 result__snippet（摘要）。
+ */
+export function parseDuckDuckGoHtml(html) {
+    const results = [];
+    const titleRe = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi;
+    const snippetRe = /<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
+    const titleMatches = [...html.matchAll(titleRe)];
+    const snippetMatches = [...html.matchAll(snippetRe)];
+    titleMatches.forEach((m, i) => {
+        const title = stripTags(m[2]);
+        const url = decodeDdgHref(m[1]);
+        const snippet = snippetMatches[i] ? stripTags(snippetMatches[i][1]) : "";
+        if (!title && !url)
+            return;
+        results.push({ title, url, snippet });
+    });
+    return results;
+}
+/** 读取响应体并限制字节数（超出截断），避免整页大文件进入上下文 */
+async function readBodyWithLimit(res, maxBytes) {
+    if (!res.body) {
+        const text = await res.text();
+        return { text, truncated: Buffer.byteLength(text, "utf8") > maxBytes };
+    }
+    const reader = res.body.getReader();
+    const chunks = [];
+    let total = 0;
+    let truncated = false;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (!value)
+            continue;
+        if (total + value.byteLength > maxBytes) {
+            const remaining = maxBytes - total;
+            if (remaining > 0)
+                chunks.push(value.subarray(0, remaining));
+            truncated = true;
+            await reader.cancel().catch(() => { });
+            break;
+        }
+        chunks.push(value);
+        total += value.byteLength;
+    }
+    return { text: Buffer.concat(chunks.map((c) => Buffer.from(c))).toString("utf8"), truncated };
+}
+/**
+ * websearch：DuckDuckGo HTML 搜索（免 API key），返回标题 + URL + 摘要。
+ * 网络失败抛错（成为 tool-error），搜索无结果返回空数组（不是错误）。
+ */
+export async function webSearchForTool(input, options = {}) {
+    const query = input.query?.trim();
+    if (!query)
+        throw new Error("query is required");
+    const maxResults = normalizeMaxResults(input.maxResults);
+    const startedAt = Date.now();
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+    const res = await fetchImpl(url, {
+        headers: {
+            "User-Agent": SEARCH_UA,
+            Accept: "text/html,application/xhtml+xml",
+        },
+        redirect: "follow",
+        signal: buildSignal(options.timeoutMs ?? WEB_SEARCH_TIMEOUT_MS, options.abortSignal),
+    });
+    if (!res.ok) {
+        throw new Error(`web search failed: HTTP ${res.status} ${res.statusText}`);
+    }
+    const { text } = await readBodyWithLimit(res, WEB_FETCH_MAX_BYTES);
+    const all = parseDuckDuckGoHtml(text);
+    const results = all.slice(0, maxResults);
+    return {
+        query,
+        results,
+        truncated: all.length > results.length,
+        durationMs: Date.now() - startedAt,
+    };
+}
+/**
+ * webfetch：HTTP GET + HTML 转纯文本。
+ * 只允许 http/https（防 file:// 等本地协议），非 2xx 抛错。
+ */
+export async function webFetchForTool(input, options = {}) {
+    const raw = input.url?.trim();
+    if (!raw)
+        throw new Error("url is required");
+    let parsed;
+    try {
+        parsed = new URL(raw);
+    }
+    catch {
+        throw new Error(`invalid URL: ${raw}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error(`unsupported protocol: ${parsed.protocol} (only http/https allowed)`);
+    }
+    const maxChars = normalizeMaxChars(input.maxChars);
+    const startedAt = Date.now();
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const res = await fetchImpl(parsed.toString(), {
+        headers: {
+            "User-Agent": SEARCH_UA,
+            Accept: "text/html,application/xhtml+xml,text/plain;q=0.9,*/*;q=0.8",
+        },
+        redirect: "follow",
+        signal: buildSignal(options.timeoutMs ?? WEB_FETCH_TIMEOUT_MS, options.abortSignal),
+    });
+    if (!res.ok) {
+        throw new Error(`HTTP ${res.status} ${res.statusText} for ${parsed.toString()}`);
+    }
+    const contentType = res.headers.get("content-type") ?? "";
+    const { text: body, truncated: bodyTruncated } = await readBodyWithLimit(res, WEB_FETCH_MAX_BYTES);
+    const title = extractHtmlTitle(body);
+    const plain = htmlToPlainText(body);
+    const text = plain.length > maxChars ? plain.slice(0, maxChars) : plain;
+    return {
+        url: parsed.toString(),
+        contentType,
+        title,
+        text,
+        chars: text.length,
+        truncated: bodyTruncated || plain.length > maxChars,
+        durationMs: Date.now() - startedAt,
+    };
+}

package/package.json

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