dsh-knowledge-library 0.1.0 → 0.2.0

package/dist/directory-settings.js

@@ -0,0 +1,92 @@
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+import { Library } from './core/library.js';
+export function createDirectorySettings(ctx, library, policy = {}) {
+    let changing = false;
+    let picking = false;
+    const editorEntry = () => {
+        const editor = ctx.get('configEditor');
+        const entry = editor?.entries().find(entry => entry.fiber === ctx.fiber);
+        return editor && entry ? { editor, entry } : undefined;
+    };
+    const capability = () => ctx.get('directoryPicker')?.capability();
+    return {
+        status() {
+            const kind = capability()?.kind;
+            const editable = !!editorEntry();
+            return { canChange: editable, canChangeNetwork: editable, picker: kind === 'native' || kind === 'browse' ? kind : null, allowProxyFakeIp: policy.allowProxyFakeIp === true };
+        },
+        async pick(signal) {
+            const picker = capability();
+            if (picker?.kind !== 'native')
+                throw new Error('当前环境不支持系统目录选择，请浏览目录或填写绝对路径');
+            if (picking)
+                throw new Error('目录选择窗口已打开');
+            picking = true;
+            try {
+                return await picker.pick(signal);
+            }
+            finally {
+                picking = false;
+            }
+        },
+        async list(path, signal) {
+            const picker = capability();
+            if (picker?.kind !== 'browse')
+                throw new Error('当前环境不支持目录浏览，请使用系统目录选择');
+            return picker.list(path, signal);
+        },
+        async change(root, expectedRoot) {
+            if (changing)
+                throw new Error('正在切换资料库，请稍候');
+            if (expectedRoot !== library.root)
+                throw new Error('资料库目录已改变，请刷新设置后重试');
+            if (!root.trim() || !isAbsolute(root) || (process.platform === 'win32' && !/^(?:[A-Za-z]:[\\/]|[\\/]{2}[^\\/]+[\\/]+[^\\/]+)/.test(root)))
+                throw new Error('请选择或填写完整的资料库绝对路径');
+            const next = resolve(root);
+            if (next === library.root)
+                return library.root;
+            const rel = relative(library.root, next);
+            const back = relative(next, library.root);
+            const inside = (value) => !!value && !isAbsolute(value) && value !== '..' && !value.startsWith(`..${sep}`);
+            if (inside(rel) || inside(back))
+                throw new Error('新旧资料库不能互相包含，请选择独立目录');
+            const target = editorEntry();
+            if (!target)
+                throw new Error('当前环境无法保存插件配置，请在 Harness 中修改资料库目录');
+            changing = true;
+            try {
+                // Check write access, the index and the single-writer lock before reloading.
+                const probe = new Library(next);
+                probe.close();
+                await target.editor.edit(target.entry, current => ({ ...current, root: next }));
+                return next;
+            }
+            finally {
+                changing = false;
+            }
+        },
+        async setProxyMode(enabled, expected, expectedRoot) {
+            if (changing)
+                throw new Error('正在保存资料库设置，请稍候');
+            if (expectedRoot !== library.root || expected !== (policy.allowProxyFakeIp === true))
+                throw new Error('资料库设置已改变，请重新打开设置后重试');
+            const target = editorEntry();
+            if (!target)
+                throw new Error('当前环境无法保存插件配置，请在 Harness 中修改采集设置');
+            if (enabled === expected)
+                return enabled;
+            changing = true;
+            try {
+                await target.editor.edit(target.entry, current => {
+                    if ((current.allowProxyFakeIp === true) !== expected)
+                        throw new Error('代理兼容设置已改变，请重新打开设置后重试');
+                    return { ...current, allowProxyFakeIp: enabled };
+                });
+                return enabled;
+            }
+            finally {
+                changing = false;
+            }
+        },
+    };
+}

package/dist/http.d.ts

@@ -1,6 +1,8 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { Library } from './core/library.js';
 import type { ImportQueue } from './core/jobs.js';
+import type { DirectorySettings } from './directory-settings.js';
+import type { KnowledgeQueue } from './core/knowledge.js';
 export declare const API_PATH = "/knowledge-library/api";
-export declare function createHandler(library: Library, queue: ImportQueue, getOrigin: () => string): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+export declare function createHandler(library: Library, queue: ImportQueue, getOrigin: () => string, directories?: DirectorySettings, knowledge?: KnowledgeQueue): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
 export declare function serveAsset(req: IncomingMessage, res: ServerResponse): void;

package/dist/http.js

@@ -31,7 +31,7 @@ function fields(data) {
     return { title: data.title, category: data.category, collection: data.collection, tags: data.tags, sourceNote: data.sourceNote, sourceUrl: data.sourceUrl };
 }
 const localAddress = (address = '') => address === '::1' || address === '127.0.0.1' || address === '::ffff:127.0.0.1';
-export function createHandler(library, queue, getOrigin) {
+export function createHandler(library, queue, getOrigin, directories, knowledge) {
     return async (req, res) => {
         try {
             const origin = getOrigin();
@@ -46,18 +46,35 @@ export function createHandler(library, queue, getOrigin) {
             const url = new URL(req.url || '/', origin);
             const path = url.pathname.slice(API_PATH.length);
             if (req.method === 'GET') {
+                if (path === '/settings') {
+                    send(res, 200, { root: library.root, ...(directories?.status() ?? { canChange: false, canChangeNetwork: false, picker: null, allowProxyFakeIp: false }) });
+                    return;
+                }
                 if (path === '/stats') {
                     send(res, 200, library.stats());
                     return;
                 }
+                if (path === '/trash') {
+                    send(res, 200, library.trashSnapshot());
+                    return;
+                }
                 if (path === '/materials') {
-                    send(res, 200, library.search({ ...Object.fromEntries(url.searchParams), limit: Number(url.searchParams.get('limit')) || 40, offset: Number(url.searchParams.get('offset')) || 0 }));
+                    send(res, 200, library.search({ ...Object.fromEntries(url.searchParams), trashed: url.searchParams.get('trashed') === '1', limit: Number(url.searchParams.get('limit')) || 40, offset: Number(url.searchParams.get('offset')) || 0 }));
                     return;
                 }
                 if (path === '/jobs') {
                     send(res, 200, queue.list());
                     return;
                 }
+                if (path === '/knowledge') {
+                    send(res, 200, knowledge?.overview() ?? { supported: false, available: false, reason: '当前服务未启用知识整理，请重启升级后的资料库服务', jobs: [], states: {} });
+                    return;
+                }
+                const knowledgeJob = path.match(/^\/knowledge\/jobs\/(knowledge_[a-f0-9-]+)$/);
+                if (knowledgeJob && knowledge) {
+                    send(res, 200, knowledge.get(knowledgeJob[1]));
+                    return;
+                }
                 const match = path.match(/^\/materials\/(r_[a-f0-9-]+)(?:\/(export|original))?$/);
                 if (match) {
                     if (match[2] === 'export') {
@@ -71,16 +88,109 @@ export function createHandler(library, queue, getOrigin) {
                         res.end(original.bytes);
                         return;
                     }
-                    send(res, 200, library.get(match[1]));
+                    const item = library.get(match[1]);
+                    send(res, 200, { ...item, missingSources: item.citations.filter(c => !library.has(c.materialId)).map(c => c.materialId) });
                     return;
                 }
             }
-            if (req.method === 'POST' || req.method === 'PATCH') {
+            if (req.method === 'POST' || req.method === 'PATCH' || req.method === 'DELETE') {
                 if (req.headers['x-knowledge-library'] !== '1') {
                     send(res, 403, { error: '缺少同源请求标记' });
                     return;
                 }
                 const data = await body(req);
+                if (path.startsWith('/knowledge/')) {
+                    if (!knowledge)
+                        throw new Error('当前服务未启用知识整理，请重启资料库服务');
+                    if (data.expectedRoot !== library.root)
+                        throw new Error('资料库目录已改变，请刷新后再操作');
+                    if (path === '/knowledge/jobs' && req.method === 'POST') {
+                        send(res, 202, knowledge.add(data.sourceIds, data.topic, data.mode));
+                        return;
+                    }
+                    const job = path.match(/^\/knowledge\/jobs\/(knowledge_[a-f0-9-]+)(?:\/(cancel|discard|confirm|plan|confirm-plan|rollback-plan))?$/);
+                    if (job) {
+                        if (req.method === 'PATCH' && job[2] === 'plan') {
+                            send(res, 200, knowledge.editPlan(job[1], data.plan, data.version));
+                            return;
+                        }
+                        if (req.method === 'POST' && job[2] === 'confirm-plan') {
+                            if (data.confirmed !== true)
+                                throw new Error('请确认分组与分类修改后再生成草稿');
+                            send(res, 200, knowledge.confirmPlan(job[1], data.version, data.applyClassification, data.expectedModel));
+                            return;
+                        }
+                        if (req.method === 'POST' && job[2] === 'rollback-plan') {
+                            if (data.confirmed !== true)
+                                throw new Error('请确认回退未完成的分类修改');
+                            send(res, 200, knowledge.rollbackPlan(job[1]));
+                            return;
+                        }
+                        if (req.method === 'PATCH' && !job[2]) {
+                            send(res, 200, knowledge.edit(job[1], data.draft, data.version, data.integration));
+                            return;
+                        }
+                        if (req.method === 'POST' && job[2] === 'cancel') {
+                            send(res, 200, knowledge.cancel(job[1]));
+                            return;
+                        }
+                        if (req.method === 'POST' && job[2] === 'discard') {
+                            send(res, 200, knowledge.discard(job[1]));
+                            return;
+                        }
+                        if (req.method === 'POST' && job[2] === 'confirm') {
+                            if (data.confirmed !== true)
+                                throw new Error('请确认保存知识笔记');
+                            const current = knowledge.get(job[1]);
+                            if (current.integration?.choice && current.integration.choice !== 'new' && data.integrationChoice !== current.integration.choice)
+                                throw new Error('请核对增量处理方式后确认，旧版页面请刷新');
+                            send(res, 200, knowledge.confirm(job[1], data.version, data.category));
+                            return;
+                        }
+                    }
+                }
+                if (req.method === 'POST' && path === '/trash/empty') {
+                    if (data.expectedRoot !== library.root)
+                        throw new Error('资料库目录已改变，请刷新后再操作');
+                    if (data.confirmed !== true || typeof data.token !== 'string')
+                        throw new Error('请先确认永久清空回收站');
+                    send(res, 200, library.emptyTrash(data.token));
+                    return;
+                }
+                if (req.method === 'POST' && ['/directory/pick', '/directory/list', '/settings/root', '/settings/network'].includes(path)) {
+                    if (!directories)
+                        throw new Error('请在 Harness 中修改资料库设置');
+                    if (path === '/settings/network') {
+                        if (typeof data.allowProxyFakeIp !== 'boolean' || typeof data.expected !== 'boolean' || typeof data.expectedRoot !== 'string')
+                            throw new Error('代理兼容设置必须是布尔值，并提供当前资料库目录');
+                        const allowProxyFakeIp = await directories.setProxyMode(data.allowProxyFakeIp, data.expected, data.expectedRoot);
+                        send(res, 200, { allowProxyFakeIp });
+                        return;
+                    }
+                    if (path === '/settings/root') {
+                        if (typeof data.root !== 'string' || typeof data.expectedRoot !== 'string')
+                            throw new Error('资料库目录必须是字符串');
+                        const root = await directories.change(data.root, data.expectedRoot);
+                        send(res, 200, { root });
+                        return;
+                    }
+                    const abort = new AbortController();
+                    const disconnected = () => abort.abort();
+                    res.once('close', disconnected);
+                    try {
+                        if (path === '/directory/pick')
+                            send(res, 200, { path: await directories.pick(abort.signal) });
+                        else {
+                            if (data.path !== undefined && typeof data.path !== 'string')
+                                throw new Error('目录路径必须是字符串');
+                            send(res, 200, await directories.list(data.path, abort.signal));
+                        }
+                    }
+                    finally {
+                        res.off('close', disconnected);
+                    }
+                    return;
+                }
                 if (req.method === 'POST' && path === '/capture') {
                     const captureFields = fields(data);
                     if (data.type === 'url' && typeof data.content === 'string') {
@@ -109,6 +219,13 @@ export function createHandler(library, queue, getOrigin) {
                     send(res, 200, library.update(match[1], fields(data)));
                     return;
                 }
+                const restore = path.match(/^\/materials\/(r_[a-f0-9-]+)\/restore$/);
+                if ((req.method === 'DELETE' && match) || (req.method === 'POST' && restore)) {
+                    if (data.expectedRoot !== library.root)
+                        throw new Error('资料库目录已改变，请刷新后再操作');
+                    send(res, 200, match ? library.trash(match[1]) : library.restore(restore[1]));
+                    return;
+                }
                 const retry = path.match(/^\/jobs\/(job_[a-f0-9-]+)\/retry$/);
                 if (req.method === 'POST' && retry) {
                     send(res, 200, queue.retry(retry[1]));

package/dist/index.js

@@ -6,6 +6,9 @@ import { ImportQueue } from './core/jobs.js';
 import { createTools } from './tools.js';
 import { API_PATH, createHandler } from './http.js';
 import { fetchPublicPage } from './core/fetch.js';
+import { createDirectorySettings } from './directory-settings.js';
+import { KnowledgeQueue } from './core/knowledge.js';
+import { harnessKnowledgeModel } from './knowledge-model.js';
 export const name = 'knowledge-library';
 export const inject = ['tools'];
 export const Config = z.object({
@@ -15,21 +18,30 @@ export const Config = z.object({
 export function apply(ctx, config) {
     const library = new Library(config.root);
     let queue;
+    let knowledge;
+    try {
+        knowledge = new KnowledgeQueue(library, harnessKnowledgeModel(ctx));
+    }
+    catch (error) {
+        library.close();
+        throw error;
+    }
     try {
         queue = new ImportQueue(library, (url, signal) => fetchPublicPage(url, signal, { allowProxyFakeIp: config.allowProxyFakeIp }));
     }
     catch (error) {
+        void knowledge.close();
         library.close();
         throw error;
     }
-    ctx.effect(() => async () => { await queue.close(); library.close(); });
-    for (const tool of createTools(library, queue))
+    ctx.effect(() => async () => { await Promise.all([queue.close(), knowledge.close()]); library.close(); });
+    for (const tool of createTools(library, queue, knowledge))
         ctx.tools.register(tool);
     ctx.inject(['webServer'], child => {
-        child.webServer.register({
+        child.effect(() => child.webServer.register({
             kind: 'prefix', path: API_PATH,
-            handler: createHandler(library, queue, () => child.webServer.getOrigin()),
-        });
+            handler: createHandler(library, queue, () => child.webServer.getOrigin(), createDirectorySettings(ctx, library, config), knowledge),
+        }));
     });
     ctx.logger.info(`资料库已加载：${library.root}`);
 }

package/dist/knowledge-model.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from '@deepseek-ai/cordis';
+export interface ModelRequest {
+    system: string;
+    prompt: string;
+    maxTokens: number;
+    signal: AbortSignal;
+}
+export interface KnowledgeModel {
+    status(): {
+        available: boolean;
+        model?: string;
+        reason?: string;
+    };
+    generate(request: ModelRequest): Promise<string>;
+}
+export declare function harnessKnowledgeModel(ctx: Context): KnowledgeModel;
+/** Preview credentials stay on the server and are never returned through HTTP. */
+export declare function previewKnowledgeModel(env?: NodeJS.ProcessEnv): KnowledgeModel;

package/dist/knowledge-model.js

@@ -0,0 +1,116 @@
+const unavailable = '请先在 Harness 设置中配置默认模型；独立预览可通过环境变量配置模型。';
+class ModelResponseError extends Error {
+}
+export function harnessKnowledgeModel(ctx) {
+    function services() {
+        const llm = ctx.get('llm');
+        const defaults = ctx.get('agentDefaultModel');
+        const selection = defaults?.currentSelection();
+        if (!llm || !selection?.provider || !selection.model || !llm.listProviders().some(p => p.id === selection.provider))
+            throw new Error(unavailable);
+        return { llm, selection };
+    }
+    return {
+        status() {
+            try {
+                const { selection } = services();
+                return { available: true, model: `${selection.provider} / ${selection.model}` };
+            }
+            catch {
+                return { available: false, reason: unavailable };
+            }
+        },
+        async generate({ system, prompt, maxTokens, signal }) {
+            const { llm, selection } = services();
+            signal.throwIfAborted();
+            let text = '';
+            let finished = false;
+            try {
+                for await (const chunk of llm.stream({ ...selection, system, messages: [{ role: 'user', content: [{ type: 'text', text: prompt }] }], maxTokens, signal })) {
+                    signal.throwIfAborted();
+                    // Complete blocks are authoritative; deltas may include reasoning or retries.
+                    if (chunk.type === 'block-end' && chunk.block.type === 'text')
+                        text += chunk.block.text;
+                    if (text.length > 60_000)
+                        throw new ModelResponseError('模型输出过长，请缩小整理范围');
+                    if (chunk.type === 'finish') {
+                        if (chunk.reason.kind !== 'stop')
+                            throw new ModelResponseError(chunk.reason.kind === 'max-tokens' ? '模型输出达到长度上限，请缩小整理范围后重试' : '模型调用未完成，请检查 Harness 模型设置后重试');
+                        finished = true;
+                    }
+                }
+            }
+            catch (error) {
+                signal.throwIfAborted();
+                if (error instanceof ModelResponseError)
+                    throw error;
+                throw new Error('模型调用失败，请检查 Harness 模型配置或网络后重试');
+            }
+            signal.throwIfAborted();
+            if (!finished || !text.trim())
+                throw new Error('模型没有返回完整正文，请重试');
+            return text;
+        },
+    };
+}
+/** Preview credentials stay on the server and are never returned through HTTP. */
+export function previewKnowledgeModel(env = process.env) {
+    const key = env.KNOWLEDGE_LIBRARY_MODEL_API_KEY || env.DEEPSEEK_API_KEY;
+    const model = env.KNOWLEDGE_LIBRARY_MODEL || 'deepseek-chat';
+    const base = env.KNOWLEDGE_LIBRARY_MODEL_BASE_URL || 'https://api.deepseek.com';
+    return {
+        status: () => key ? { available: true, model } : { available: false, reason: unavailable },
+        async generate({ system, prompt, maxTokens, signal }) {
+            if (!key)
+                throw new Error(unavailable);
+            let response;
+            try {
+                const url = new URL(`${base.replace(/\/$/, '')}/chat/completions`);
+                if (!['https:', 'http:'].includes(url.protocol) || url.username || url.password)
+                    throw new Error();
+                response = await fetch(url, { method: 'POST', redirect: 'error', signal,
+                    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${key}` },
+                    body: JSON.stringify({ model, stream: false, max_tokens: maxTokens, messages: [{ role: 'system', content: system }, { role: 'user', content: prompt }] }) });
+            }
+            catch {
+                signal.throwIfAborted();
+                throw new Error('模型连接失败，请检查服务地址和网络后重试');
+            }
+            if (!response.ok) {
+                await response.body?.cancel();
+                throw new Error(`模型调用失败（HTTP ${response.status}），请检查模型配置或额度`);
+            }
+            // Bound bytes before JSON parsing, including chunked responses.
+            const reader = response.body?.getReader();
+            if (!reader)
+                throw new Error('模型响应为空');
+            const chunks = [];
+            let length = 0;
+            try {
+                while (true) {
+                    const part = await reader.read();
+                    if (part.done)
+                        break;
+                    length += part.value.length;
+                    if (length > 512_000)
+                        throw new Error('模型响应过大，请缩小整理范围');
+                    chunks.push(part.value);
+                }
+            }
+            finally {
+                await reader.cancel().catch(() => { });
+            }
+            let data;
+            try {
+                data = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+            }
+            catch {
+                throw new Error('模型响应不是有效 JSON');
+            }
+            const choice = data.choices?.[0];
+            if (choice?.finish_reason !== 'stop' || typeof choice.message?.content !== 'string' || !choice.message.content.trim())
+                throw new Error('模型未返回完整正文，可能达到输出上限，请缩小范围后重试');
+            return choice.message.content;
+        },
+    };
+}

package/dist/preview-settings.d.ts

@@ -0,0 +1,6 @@
+import type { DirectorySettings } from './directory-settings.js';
+import { type Library } from './core/library.js';
+import type { FetchPolicy } from './core/fetch.js';
+export declare function createPreviewSettings(library: Library, defaults?: FetchPolicy): DirectorySettings & {
+    fetchPolicy(): FetchPolicy;
+};

package/dist/preview-settings.js

@@ -0,0 +1,42 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { atomicJson } from './core/library.js';
+export function createPreviewSettings(library, defaults = {}) {
+    const file = join(library.root, '.system', 'preview-settings.json');
+    let allowProxyFakeIp = defaults.allowProxyFakeIp === true;
+    if (existsSync(file)) {
+        let stored;
+        try {
+            stored = JSON.parse(readFileSync(file, 'utf8'));
+        }
+        catch {
+            throw new Error('独立预览设置读取失败，请检查 .system/preview-settings.json');
+        }
+        if (stored?.schemaVersion !== 1 || typeof stored.allowProxyFakeIp !== 'boolean')
+            throw new Error('独立预览设置格式不正确，请检查 .system/preview-settings.json');
+        allowProxyFakeIp = stored.allowProxyFakeIp;
+    }
+    const unsupported = async () => { throw new Error('独立预览请通过启动配置指定资料库目录'); };
+    return {
+        status: () => ({ canChange: false, canChangeNetwork: true, picker: null, allowProxyFakeIp }),
+        // Each request keeps its own policy even if settings change during a redirect.
+        fetchPolicy: () => ({ allowProxyFakeIp }),
+        pick: unsupported,
+        list: unsupported,
+        change: unsupported,
+        async setProxyMode(enabled, expected, expectedRoot) {
+            if (expectedRoot !== library.root || expected !== allowProxyFakeIp)
+                throw new Error('资料库设置已改变，请重新打开设置后重试');
+            if (enabled === allowProxyFakeIp)
+                return enabled;
+            try {
+                atomicJson(file, { schemaVersion: 1, allowProxyFakeIp: enabled });
+            }
+            catch {
+                throw new Error('采集设置保存失败，请检查资料库目录的写入权限；原设置未改变');
+            }
+            allowProxyFakeIp = enabled;
+            return enabled;
+        },
+    };
+}