xz
1233 lines
58 KiB
JavaScript
1233 lines
58 KiB
JavaScript
import { dbAll, dbGet, dbRun, withTransaction } from "./db.mjs";
|
||
import { addAudit, addUsage, hasPermission, httpError, requireEntitlement, requirePermission, requireProjectWritable } from "./tenant.mjs";
|
||
import { importScript } from "./production.mjs";
|
||
|
||
const now = () => new Date().toISOString();
|
||
const makeId = (prefix) => `${prefix}-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
|
||
|
||
function parseJson(value, fallback) {
|
||
try {
|
||
return JSON.parse(value);
|
||
} catch {
|
||
return fallback;
|
||
}
|
||
}
|
||
|
||
function unique(values) {
|
||
return [...new Set((values || []).map((item) => String(item || "").trim()).filter(Boolean))];
|
||
}
|
||
|
||
function normalizeTags(value) {
|
||
if (Array.isArray(value)) return unique(value).slice(0, 24);
|
||
return unique(String(value || "").split(/[,，、\s]+/)).slice(0, 24);
|
||
}
|
||
|
||
function normalizeRightsStatus(value) {
|
||
const status = String(value || "needs-evidence").trim();
|
||
if (["needs-evidence", "submitted", "approved", "rejected", "expired"].includes(status)) return status;
|
||
return "needs-evidence";
|
||
}
|
||
|
||
function normalizeProvenance(body = {}, fallback = {}) {
|
||
const source = body.provenance && typeof body.provenance === "object" ? body.provenance : {};
|
||
const metadata = body.metadata && typeof body.metadata === "object" ? body.metadata : {};
|
||
return {
|
||
sourceLabel: String(source.sourceLabel || metadata.sourceLabel || fallback.sourceLabel || "").trim(),
|
||
author: String(source.author || metadata.author || fallback.author || "").trim(),
|
||
rightsOwner: String(source.rightsOwner || metadata.rightsOwner || fallback.rightsOwner || "").trim(),
|
||
evidenceRef: String(source.evidenceRef || metadata.evidenceRef || fallback.evidenceRef || "").trim(),
|
||
licenseNote: String(source.licenseNote || metadata.licenseNote || fallback.licenseNote || "").trim(),
|
||
sourceUrl: String(source.sourceUrl || metadata.sourceUrl || fallback.sourceUrl || "").trim(),
|
||
importedFrom: String(source.importedFrom || metadata.importedFrom || fallback.importedFrom || "manual").trim()
|
||
};
|
||
}
|
||
|
||
function approxTokens(text) {
|
||
const value = String(text || "").trim();
|
||
return Math.max(1, Math.ceil(value.length / 1.8));
|
||
}
|
||
|
||
function splitSections(content) {
|
||
const normalized = String(content || "").replace(/\r/g, "").trim();
|
||
const lines = normalized.split("\n");
|
||
const headingPattern = /^(第[0-9一二三四五六七八九十百零]+[章节集幕]|chapter\s*\d+|CHAPTER\s*\d+)/i;
|
||
const sections = [];
|
||
let currentTitle = "";
|
||
let buffer = [];
|
||
for (const rawLine of lines) {
|
||
const line = rawLine.trim();
|
||
if (headingPattern.test(line)) {
|
||
if (currentTitle || buffer.length) sections.push({ title: currentTitle || `片段 ${sections.length + 1}`, content: buffer.join("\n").trim() });
|
||
currentTitle = line;
|
||
buffer = [];
|
||
} else {
|
||
buffer.push(rawLine);
|
||
}
|
||
}
|
||
if (currentTitle || buffer.length) sections.push({ title: currentTitle || `片段 ${sections.length + 1}`, content: buffer.join("\n").trim() });
|
||
if (sections.length) return sections.filter((section) => section.content);
|
||
const paragraphs = normalized.split(/\n\s*\n/).map((item) => item.trim()).filter(Boolean);
|
||
if (!paragraphs.length) return [];
|
||
const grouped = [];
|
||
for (let index = 0; index < paragraphs.length; index += 3) {
|
||
grouped.push({
|
||
title: `片段 ${grouped.length + 1}`,
|
||
content: paragraphs.slice(index, index + 3).join("\n\n")
|
||
});
|
||
}
|
||
return grouped;
|
||
}
|
||
|
||
function extractEntities(text) {
|
||
const value = String(text || "");
|
||
const characters = unique([...value.matchAll(/([\u4e00-\u9fa5]{2,4})[：:]/g)].map((match) => match[1]));
|
||
const locationKeywords = ["地铁口", "玻璃连廊", "雨棚", "教室", "客厅", "街道", "医院", "仓库", "山路", "门口", "旧城区", "天台", "楼道"];
|
||
const propKeywords = ["手机", "雨伞", "蓝伞", "雨披", "黄色雨披", "路锥", "警戒线", "钥匙", "刀", "书包", "项链", "文件", "录音笔", "相机"];
|
||
const locations = unique(locationKeywords.filter((item) => value.includes(item)));
|
||
const props = unique(propKeywords.filter((item) => value.includes(item)));
|
||
return { characters, locations, props };
|
||
}
|
||
|
||
function keywordsForText(text, entities) {
|
||
const base = String(text || "").replace(/[，。！？、：“”"'（）()【】\[\]\s]+/g, " ").trim().split(" ").filter(Boolean);
|
||
return unique([...(entities.characters || []), ...(entities.locations || []), ...(entities.props || []), ...base.filter((item) => item.length >= 2).slice(0, 6)]).slice(0, 10);
|
||
}
|
||
|
||
function chunkTypeForContent(text, sectionIndex, paragraphIndex) {
|
||
const value = String(text || "");
|
||
const dialogueMatches = [...value.matchAll(/^[\u4e00-\u9fa5]{2,4}[：:]/gm)];
|
||
if (dialogueMatches.length >= 2) return "dialogue";
|
||
if (/设定|规则|传说|前史|背景/.test(value)) return "lore";
|
||
if (paragraphIndex === 0) return sectionIndex === 0 ? "chapter" : "scene";
|
||
return "scene";
|
||
}
|
||
|
||
function analyzeKnowledgeText(content) {
|
||
const sections = splitSections(content);
|
||
const chunks = [];
|
||
const chapterSummary = [];
|
||
let chunkIndex = 1;
|
||
for (let sectionIndex = 0; sectionIndex < sections.length; sectionIndex += 1) {
|
||
const section = sections[sectionIndex];
|
||
const parts = section.content.split(/\n\s*\n/).map((item) => item.trim()).filter(Boolean);
|
||
const merged = [];
|
||
for (const part of parts) {
|
||
if (!merged.length) {
|
||
merged.push(part);
|
||
continue;
|
||
}
|
||
if (merged[merged.length - 1].length < 180) merged[merged.length - 1] = `${merged[merged.length - 1]}\n${part}`;
|
||
else merged.push(part);
|
||
}
|
||
const startChunk = chunkIndex;
|
||
for (let paragraphIndex = 0; paragraphIndex < merged.length; paragraphIndex += 1) {
|
||
const body = merged[paragraphIndex];
|
||
const entities = extractEntities(body);
|
||
chunks.push({
|
||
id: `chunk-${chunkIndex}`,
|
||
chunkIndex,
|
||
chunkType: chunkTypeForContent(body, sectionIndex, paragraphIndex),
|
||
heading: section.title || `片段 ${sectionIndex + 1}`,
|
||
content: body,
|
||
tokenEstimate: approxTokens(body),
|
||
keywords: keywordsForText(body, entities),
|
||
entities,
|
||
metadata: {
|
||
sectionIndex: sectionIndex + 1,
|
||
paragraphIndex: paragraphIndex + 1,
|
||
sceneHint: paragraphIndex === 0 ? "段首情境建立" : /[：:]/.test(body) ? "对白块" : "叙事块"
|
||
}
|
||
});
|
||
chunkIndex += 1;
|
||
}
|
||
chapterSummary.push({
|
||
id: `section-${sectionIndex + 1}`,
|
||
title: section.title || `片段 ${sectionIndex + 1}`,
|
||
words: section.content.replace(/\s/g, "").length,
|
||
chunkCount: chunkIndex - startChunk
|
||
});
|
||
}
|
||
const allEntities = chunks.reduce((accumulator, chunk) => ({
|
||
characters: [...accumulator.characters, ...(chunk.entities.characters || [])],
|
||
locations: [...accumulator.locations, ...(chunk.entities.locations || [])],
|
||
props: [...accumulator.props, ...(chunk.entities.props || [])]
|
||
}), { characters: [], locations: [], props: [] });
|
||
const text = String(content || "").trim();
|
||
return {
|
||
parser: "local-rule-v2",
|
||
summary: text.slice(0, 120),
|
||
chapterCount: chapterSummary.length,
|
||
chunkCount: chunks.length,
|
||
chapters: chapterSummary,
|
||
entities: {
|
||
characters: unique(allEntities.characters),
|
||
locations: unique(allEntities.locations),
|
||
props: unique(allEntities.props)
|
||
},
|
||
chunks
|
||
};
|
||
}
|
||
|
||
function scanKnowledgeGovernance({ title = "", content = "", sourceType = "", rightsStatus = "needs-evidence", provenance = {}, tags = [] } = {}) {
|
||
const text = `${title}\n${content}`.toLowerCase();
|
||
const issues = [];
|
||
const pushIssue = (severity, code, message, matches = []) => issues.push({ severity, code, message, matches: unique(matches).slice(0, 8) });
|
||
const normalizedRights = normalizeRightsStatus(rightsStatus);
|
||
const evidenceRef = String(provenance.evidenceRef || provenance.sourceLabel || "").trim();
|
||
if (normalizedRights === "rejected" || normalizedRights === "expired") {
|
||
pushIssue("blocking", "rights_not_usable", "素材版权状态不可用于商用生产。");
|
||
} else if (normalizedRights !== "approved") {
|
||
pushIssue("review", "rights_needs_evidence", "素材尚未批准商用使用，正式生产前需要补充来源/授权证据。");
|
||
}
|
||
if (!evidenceRef) {
|
||
pushIssue("review", "provenance_evidence_missing", "缺少来源或授权证据引用。");
|
||
}
|
||
|
||
const ipTerms = ["迪士尼", "漫威", "哈利波特", "火影忍者", "海贼王", "斗罗大陆", "狐妖小红娘", "三体", "庆余年", "盗墓笔记", "鬼吹灯", "原神", "王者荣耀"];
|
||
const ipMatches = ipTerms.filter((term) => text.includes(term.toLowerCase()));
|
||
if (ipMatches.length) pushIssue("review", "known_ip_reference", "文本含有已知商业 IP 或游戏/影视/小说名称，需要确认不是仿作或未授权改编。", ipMatches);
|
||
|
||
const personaTerms = ["仿明星", "明星脸", "真人脸", "照着某人", "像某明星", "某某同款", "高仿演员", "数字替身"];
|
||
const personaMatches = personaTerms.filter((term) => text.includes(term.toLowerCase()));
|
||
if (personaMatches.length) pushIssue("review", "persona_likeness_risk", "文本含有真人形象或仿冒表达，后续角色/视频生成需要权利人授权。", personaMatches);
|
||
|
||
const layoutTerms = ["split-screen", "comic panel", "collage", "contact sheet", "storyboard", "多格", "拼图", "分屏", "九宫格", "故事板"];
|
||
const layoutMatches = layoutTerms.filter((term) => text.includes(term.toLowerCase()));
|
||
if (layoutMatches.length) pushIssue("warn", "single_frame_policy_risk", "素材或提示中含一图多画面表达，进入画面生成前必须改写为单一完整画面。", layoutMatches);
|
||
|
||
const sensitiveTerms = ["血腥特写", "未成年人裸露", "自残教程", "诈骗话术", "真实身份证", "银行卡号"];
|
||
const sensitiveMatches = sensitiveTerms.filter((term) => text.includes(term.toLowerCase()));
|
||
if (sensitiveMatches.length) pushIssue("blocking", "safety_sensitive_content", "文本含高风险安全或隐私内容，不能直接进入自动生成。", sensitiveMatches);
|
||
|
||
const score = issues.reduce((sum, issue) => sum + (issue.severity === "blocking" ? 60 : issue.severity === "review" ? 24 : 10), 0);
|
||
const status = issues.some((issue) => issue.severity === "blocking") ? "blocked" : issues.some((issue) => issue.severity === "review") ? "review" : issues.some((issue) => issue.severity === "warn") ? "warn" : "pass";
|
||
return {
|
||
scanner: "local-governance-v1",
|
||
status,
|
||
score: Math.min(100, score),
|
||
rightsStatus: normalizedRights,
|
||
sourceType,
|
||
tags,
|
||
issues,
|
||
checks: {
|
||
provenanceEvidence: Boolean(evidenceRef),
|
||
commercialRightsApproved: normalizedRights === "approved",
|
||
knownIpReferences: ipMatches.length,
|
||
personaLikenessRisks: personaMatches.length,
|
||
singleFramePolicyRisks: layoutMatches.length,
|
||
safetySensitiveMatches: sensitiveMatches.length
|
||
},
|
||
scannedAt: now()
|
||
};
|
||
}
|
||
|
||
function normalizeGovernanceDecision(value) {
|
||
const decision = String(value || "submitted").trim();
|
||
if (["submitted", "approved", "rejected", "needs-revision"].includes(decision)) return decision;
|
||
return "submitted";
|
||
}
|
||
|
||
function normalizeDocumentStatus(value, fallback = "indexed") {
|
||
const status = String(value || fallback || "indexed").trim();
|
||
if (["ingested", "indexed", "draft", "active", "archived"].includes(status)) return status;
|
||
return fallback || "indexed";
|
||
}
|
||
|
||
function serializeKnowledgeReviewRow(row) {
|
||
if (!row) return null;
|
||
return {
|
||
id: row.id,
|
||
documentId: row.document_id,
|
||
decision: row.decision,
|
||
rightsStatus: row.rights_status,
|
||
riskStatus: row.risk_status,
|
||
notes: row.notes || "",
|
||
evidenceRef: row.evidence_ref || "",
|
||
provenance: parseJson(row.provenance_json, {}),
|
||
risk: parseJson(row.risk_json, {}),
|
||
reviewerUserId: row.reviewer_user_id || "",
|
||
createdAt: row.created_at || ""
|
||
};
|
||
}
|
||
|
||
function latestKnowledgeReview(documentId) {
|
||
return serializeKnowledgeReviewRow(dbGet(
|
||
`SELECT *
|
||
FROM knowledge_governance_reviews
|
||
WHERE document_id = ?
|
||
ORDER BY created_at DESC
|
||
LIMIT 1`,
|
||
[documentId]
|
||
));
|
||
}
|
||
|
||
function knowledgeVersionCount(documentId) {
|
||
const row = dbGet("SELECT COUNT(*) AS count FROM knowledge_document_versions WHERE document_id = ?", [documentId]);
|
||
return Number(row?.count || 0);
|
||
}
|
||
|
||
function nextKnowledgeVersionNumber(documentId) {
|
||
const row = dbGet("SELECT COALESCE(MAX(version_number), 0) + 1 AS version_number FROM knowledge_document_versions WHERE document_id = ?", [documentId]);
|
||
return Number(row?.version_number || 1);
|
||
}
|
||
|
||
function serializeKnowledgeDocumentRow(row, chunks = null) {
|
||
const analysis = parseJson(row.analysis_json, {});
|
||
const metadata = parseJson(row.metadata_json, {});
|
||
const provenance = parseJson(row.provenance_json, {});
|
||
const tags = parseJson(row.tags_json, []);
|
||
const risk = parseJson(row.risk_json, {});
|
||
const versionCount = row.version_count === undefined ? knowledgeVersionCount(row.id) : Number(row.version_count || 0);
|
||
return {
|
||
...row,
|
||
sourceType: row.source_type || "",
|
||
projectId: row.project_id || "",
|
||
scopeMode: row.scope_mode || "workspace",
|
||
rightsStatus: row.rights_status || "needs-evidence",
|
||
provenance,
|
||
tags,
|
||
risk,
|
||
riskStatus: risk.status || "unscanned",
|
||
riskScore: Number(risk.score || 0),
|
||
currentVersionNumber: Number(row.current_version_number || 1),
|
||
versionCount,
|
||
latestReview: latestKnowledgeReview(row.id),
|
||
summary: row.summary || "",
|
||
chunkCount: Number(row.chunk_count || chunks?.length || 0),
|
||
analysis,
|
||
metadata,
|
||
chunks: chunks || undefined
|
||
};
|
||
}
|
||
|
||
function serializeKnowledgeVersionRow(row) {
|
||
return {
|
||
id: row.id,
|
||
documentId: row.document_id,
|
||
versionNumber: Number(row.version_number || 0),
|
||
title: row.title || "",
|
||
sourceType: row.source_type || "novel",
|
||
language: row.language || "zh-CN",
|
||
content: row.content || "",
|
||
summary: row.summary || "",
|
||
analysis: parseJson(row.analysis_json, {}),
|
||
provenance: parseJson(row.provenance_json, {}),
|
||
tags: parseJson(row.tags_json, []),
|
||
risk: parseJson(row.risk_json, {}),
|
||
metadata: parseJson(row.metadata_json, {}),
|
||
createdBy: row.created_by || "",
|
||
createdAt: row.created_at || ""
|
||
};
|
||
}
|
||
|
||
function writeKnowledgeChunks(documentId, chunks, timestamp) {
|
||
for (const chunk of chunks) {
|
||
dbRun(
|
||
`INSERT INTO knowledge_chunks(
|
||
id, document_id, chunk_index, chunk_type, heading, content, token_estimate,
|
||
keywords_json, entities_json, metadata_json, created_at
|
||
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
||
[`${documentId}-${chunk.chunkIndex}`, documentId, chunk.chunkIndex, chunk.chunkType, chunk.heading, chunk.content, chunk.tokenEstimate, JSON.stringify(chunk.keywords), JSON.stringify(chunk.entities), JSON.stringify(chunk.metadata), timestamp]
|
||
);
|
||
}
|
||
}
|
||
|
||
function insertKnowledgeVersion(context, document, versionNumber, timestamp, metadataPatch = {}) {
|
||
const metadata = document.metadata && typeof document.metadata === "object" ? document.metadata : parseJson(document.metadata_json, {});
|
||
const analysis = document.analysis && typeof document.analysis === "object" ? document.analysis : parseJson(document.analysis_json, {});
|
||
const provenance = document.provenance && typeof document.provenance === "object" ? document.provenance : parseJson(document.provenance_json, {});
|
||
const tags = Array.isArray(document.tags) ? document.tags : parseJson(document.tags_json, []);
|
||
const risk = document.risk && typeof document.risk === "object" ? document.risk : parseJson(document.risk_json, {});
|
||
dbRun(
|
||
`INSERT INTO knowledge_document_versions(
|
||
id, document_id, version_number, title, source_type, language, content, summary,
|
||
analysis_json, provenance_json, tags_json, risk_json, metadata_json, created_by, created_at
|
||
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
||
[
|
||
String(metadataPatch.id || `${document.id}-v${versionNumber}`),
|
||
document.id,
|
||
versionNumber,
|
||
document.title,
|
||
document.sourceType || document.source_type || "novel",
|
||
document.language || "zh-CN",
|
||
document.content || "",
|
||
document.summary || "",
|
||
JSON.stringify({ ...analysis, chunks: undefined }),
|
||
JSON.stringify(provenance),
|
||
JSON.stringify(tags),
|
||
JSON.stringify(risk),
|
||
JSON.stringify({ ...metadata, ...metadataPatch }),
|
||
context.user.id,
|
||
timestamp
|
||
]
|
||
);
|
||
}
|
||
|
||
function assertKnowledgeDocumentUsable(document) {
|
||
const risk = document.risk || parseJson(document.risk_json, {});
|
||
const rightsStatus = document.rightsStatus || document.rights_status || "needs-evidence";
|
||
if (["rejected", "expired"].includes(rightsStatus)) {
|
||
throw httpError(409, "knowledge_rights_not_usable", "该素材版权状态不可用于商用生产，请先完成授权治理", { documentId: document.id, rightsStatus });
|
||
}
|
||
if (risk.status === "blocked") {
|
||
throw httpError(409, "knowledge_risk_blocked", "该素材风险扫描为阻断状态，不能进入生成或剧本生产", { documentId: document.id, risk });
|
||
}
|
||
}
|
||
|
||
function summarizePackGovernance(chunks) {
|
||
const summary = chunks.reduce((accumulator, chunk) => {
|
||
const rightsStatus = chunk.rightsStatus || "needs-evidence";
|
||
const riskStatus = chunk.risk?.status || "unscanned";
|
||
accumulator.rights[rightsStatus] = (accumulator.rights[rightsStatus] || 0) + 1;
|
||
accumulator.risk[riskStatus] = (accumulator.risk[riskStatus] || 0) + 1;
|
||
if (["rejected", "expired"].includes(rightsStatus) || riskStatus === "blocked") accumulator.blocking += 1;
|
||
if (rightsStatus !== "approved" || ["review", "warn"].includes(riskStatus)) accumulator.review += 1;
|
||
return accumulator;
|
||
}, { rights: {}, risk: {}, blocking: 0, review: 0 });
|
||
return {
|
||
status: summary.blocking ? "blocked" : summary.review ? "review" : "pass",
|
||
rights: summary.rights,
|
||
risk: summary.risk,
|
||
blockingCount: summary.blocking,
|
||
reviewCount: summary.review
|
||
};
|
||
}
|
||
|
||
function assertPackGovernanceUsable(pack) {
|
||
const governance = pack?.governance || pack?.metadata?.governance || {};
|
||
if (governance.status === "blocked" || Number(governance.blockingCount || 0) > 0) {
|
||
throw httpError(409, "knowledge_pack_blocked", "上下文包包含版权不可用或风险阻断素材，不能进入生产任务", { packId: pack.id, governance });
|
||
}
|
||
}
|
||
|
||
function scopedKnowledgeQuery(context) {
|
||
const params = [context.organization.id, context.workspace.id];
|
||
let clause = "kd.organization_id = ? AND kd.workspace_id = ?";
|
||
if (context.project?.id) {
|
||
clause += " AND (kd.project_id IS NULL OR kd.project_id = ?)";
|
||
params.push(context.project.id);
|
||
} else {
|
||
clause += " AND kd.project_id IS NULL";
|
||
}
|
||
return { clause, params };
|
||
}
|
||
|
||
function scopedKnowledgePackQuery(context) {
|
||
const params = [context.organization.id, context.workspace.id];
|
||
let clause = "kcp.organization_id = ? AND kcp.workspace_id = ?";
|
||
if (context.project?.id) {
|
||
clause += " AND (kcp.project_id IS NULL OR kcp.project_id = ?)";
|
||
params.push(context.project.id);
|
||
} else {
|
||
clause += " AND kcp.project_id IS NULL";
|
||
}
|
||
return { clause, params };
|
||
}
|
||
|
||
function placeholders(values) {
|
||
return values.map(() => "?").join(",");
|
||
}
|
||
|
||
function likePattern(value) {
|
||
return `%${String(value || "").trim().replace(/[\\%_]/g, "\\$&").slice(0, 100)}%`;
|
||
}
|
||
|
||
function knowledgeTerms(query) {
|
||
const normalized = String(query || "").trim();
|
||
if (!normalized) return [];
|
||
const split = normalized.split(/[\s,，。；;、/|]+/).map((item) => item.trim()).filter(Boolean);
|
||
return unique([normalized, ...split]).slice(0, 8);
|
||
}
|
||
|
||
function normalizeKnowledgeChunk(row) {
|
||
const entities = parseJson(row.entities_json, {});
|
||
const keywords = parseJson(row.keywords_json, []);
|
||
const risk = parseJson(row.risk_json, {});
|
||
return {
|
||
id: row.id,
|
||
documentId: row.document_id,
|
||
documentTitle: row.document_title || row.title || "",
|
||
chunkIndex: Number(row.chunk_index || 0),
|
||
chunkType: row.chunk_type || "scene",
|
||
heading: row.heading || "",
|
||
content: row.content || "",
|
||
tokenEstimate: Number(row.token_estimate || approxTokens(row.content)),
|
||
keywords,
|
||
entities,
|
||
metadata: parseJson(row.metadata_json, {}),
|
||
sourceType: row.source_type || "",
|
||
language: row.language || "zh-CN",
|
||
scopeMode: row.scope_mode || "workspace",
|
||
rightsStatus: row.rights_status || "needs-evidence",
|
||
risk,
|
||
riskStatus: risk.status || "unscanned",
|
||
projectId: row.project_id || "",
|
||
organizationId: row.organization_id || "",
|
||
workspaceId: row.workspace_id || "",
|
||
updatedAt: row.updated_at || row.created_at || ""
|
||
};
|
||
}
|
||
|
||
function flattenEntities(entities = {}) {
|
||
return unique([...(entities.characters || []), ...(entities.locations || []), ...(entities.props || [])]);
|
||
}
|
||
|
||
function scoreKnowledgeChunk(chunk, terms) {
|
||
if (!terms.length) return 1;
|
||
const haystacks = {
|
||
title: `${chunk.documentTitle}`.toLowerCase(),
|
||
heading: `${chunk.heading}`.toLowerCase(),
|
||
content: `${chunk.content}`.toLowerCase(),
|
||
keywords: (chunk.keywords || []).join(" ").toLowerCase(),
|
||
entities: flattenEntities(chunk.entities).join(" ").toLowerCase()
|
||
};
|
||
let score = 0;
|
||
for (const rawTerm of terms) {
|
||
const term = rawTerm.toLowerCase();
|
||
if (!term) continue;
|
||
if (haystacks.title.includes(term)) score += 80;
|
||
if (haystacks.heading.includes(term)) score += 64;
|
||
if (haystacks.keywords.includes(term)) score += 44;
|
||
if (haystacks.entities.includes(term)) score += 38;
|
||
if (haystacks.content.includes(term)) score += 26;
|
||
}
|
||
if (chunk.chunkType === "dialogue") score += 5;
|
||
if (chunk.scopeMode === "project") score += 3;
|
||
return score;
|
||
}
|
||
|
||
function snippetFor(content, terms, maxLength = 180) {
|
||
const text = String(content || "").replace(/\s+/g, " ").trim();
|
||
if (text.length <= maxLength) return text;
|
||
const lower = text.toLowerCase();
|
||
const term = terms.map((item) => item.toLowerCase()).find((item) => item && lower.includes(item));
|
||
if (!term) return `${text.slice(0, maxLength - 1)}…`;
|
||
const index = lower.indexOf(term);
|
||
const start = Math.max(0, index - Math.floor(maxLength / 3));
|
||
const end = Math.min(text.length, start + maxLength);
|
||
return `${start > 0 ? "…" : ""}${text.slice(start, end)}${end < text.length ? "…" : ""}`;
|
||
}
|
||
|
||
function serializeContextPackRow(row) {
|
||
const chunkIds = parseJson(row.chunk_ids_json, []);
|
||
const citations = parseJson(row.citations_json, []);
|
||
const chunks = parseJson(row.chunks_json, []);
|
||
const metadata = parseJson(row.metadata_json, {});
|
||
return {
|
||
schema: "ai-drama.knowledge-context-pack.v1",
|
||
id: row.id,
|
||
name: row.name || "",
|
||
query: row.query || "",
|
||
sourceType: row.source_type || "mixed",
|
||
projectId: row.project_id || "",
|
||
scopeMode: row.scope_mode || "workspace",
|
||
maxTokens: Number(row.max_tokens || 0),
|
||
tokenEstimate: Number(row.token_estimate || 0),
|
||
selectedCount: chunks.length || chunkIds.length,
|
||
chunkIds,
|
||
citations,
|
||
chunks,
|
||
promptContext: row.prompt_context || "",
|
||
governance: metadata.governance || {},
|
||
status: row.status || "active",
|
||
metadata,
|
||
createdBy: row.created_by || "",
|
||
createdAt: row.created_at || "",
|
||
updatedAt: row.updated_at || ""
|
||
};
|
||
}
|
||
|
||
function knowledgeDocumentDetail(context, documentId) {
|
||
const { clause, params } = scopedKnowledgeQuery(context);
|
||
const row = dbGet(
|
||
`SELECT kd.*,
|
||
(SELECT COUNT(*) FROM knowledge_chunks kc WHERE kc.document_id = kd.id) AS chunk_count,
|
||
(SELECT COUNT(*) FROM knowledge_document_versions kdv WHERE kdv.document_id = kd.id) AS version_count
|
||
FROM knowledge_documents kd
|
||
WHERE kd.id = ? AND ${clause}`,
|
||
[documentId, ...params]
|
||
);
|
||
if (!row) return null;
|
||
const chunks = dbAll(
|
||
`SELECT * FROM knowledge_chunks
|
||
WHERE document_id = ?
|
||
ORDER BY chunk_index`,
|
||
[documentId]
|
||
).map((chunk) => ({
|
||
...chunk,
|
||
chunkIndex: Number(chunk.chunk_index || 0),
|
||
tokenEstimate: Number(chunk.token_estimate || 0),
|
||
keywords: parseJson(chunk.keywords_json, []),
|
||
entities: parseJson(chunk.entities_json, {}),
|
||
metadata: parseJson(chunk.metadata_json, {})
|
||
}));
|
||
return serializeKnowledgeDocumentRow(row, chunks);
|
||
}
|
||
|
||
export function listKnowledgeDocuments(context) {
|
||
requirePermission(context, "script:read");
|
||
const { clause, params } = scopedKnowledgeQuery(context);
|
||
const rows = dbAll(
|
||
`SELECT kd.*,
|
||
(SELECT COUNT(*) FROM knowledge_chunks kc WHERE kc.document_id = kd.id) AS chunk_count,
|
||
(SELECT COUNT(*) FROM knowledge_document_versions kdv WHERE kdv.document_id = kd.id) AS version_count
|
||
FROM knowledge_documents kd
|
||
WHERE ${clause}
|
||
ORDER BY kd.updated_at DESC, kd.created_at DESC`,
|
||
params
|
||
);
|
||
const documents = rows.map((row) => serializeKnowledgeDocumentRow(row));
|
||
return {
|
||
documents,
|
||
summary: {
|
||
total: documents.length,
|
||
workspaceScoped: documents.filter((item) => item.scopeMode === "workspace").length,
|
||
projectScoped: documents.filter((item) => item.scopeMode === "project").length,
|
||
chunks: documents.reduce((sum, item) => sum + Number(item.chunkCount || 0), 0),
|
||
rightsApproved: documents.filter((item) => item.rightsStatus === "approved").length,
|
||
rightsNeedsEvidence: documents.filter((item) => item.rightsStatus !== "approved").length,
|
||
riskBlocked: documents.filter((item) => item.riskStatus === "blocked").length,
|
||
riskReview: documents.filter((item) => item.riskStatus === "review").length,
|
||
versions: documents.reduce((sum, item) => sum + Number(item.versionCount || 0), 0)
|
||
}
|
||
};
|
||
}
|
||
|
||
export function getKnowledgeDocument(context, documentId) {
|
||
requirePermission(context, "script:read");
|
||
const document = knowledgeDocumentDetail(context, documentId);
|
||
if (!document) throw httpError(404, "knowledge_document_not_found", "知识库文档不存在或不属于当前作用域", { documentId });
|
||
return { document };
|
||
}
|
||
|
||
export function searchKnowledge(context, body = {}) {
|
||
requirePermission(context, "script:read");
|
||
const query = String(body.query || body.q || "").trim().slice(0, 120);
|
||
const sourceType = String(body.sourceType || body.source_type || "all").trim();
|
||
const scopeMode = String(body.scopeMode || body.scope_mode || "all").trim();
|
||
const limit = Math.max(1, Math.min(80, Number(body.limit || 24)));
|
||
const terms = knowledgeTerms(query);
|
||
const { clause, params } = scopedKnowledgeQuery(context);
|
||
const where = [clause, "kd.status <> 'archived'"];
|
||
const queryParams = [...params];
|
||
if (sourceType && sourceType !== "all") {
|
||
where.push("kd.source_type = ?");
|
||
queryParams.push(sourceType);
|
||
}
|
||
if (["workspace", "project"].includes(scopeMode)) {
|
||
where.push("kd.scope_mode = ?");
|
||
queryParams.push(scopeMode);
|
||
}
|
||
if (terms.length) {
|
||
const termClauses = [];
|
||
for (const term of terms) {
|
||
termClauses.push("(kd.title LIKE ? ESCAPE '\\' OR kd.summary LIKE ? ESCAPE '\\' OR kc.heading LIKE ? ESCAPE '\\' OR kc.content LIKE ? ESCAPE '\\' OR kc.keywords_json LIKE ? ESCAPE '\\' OR kc.entities_json LIKE ? ESCAPE '\\')");
|
||
const pattern = likePattern(term);
|
||
queryParams.push(pattern, pattern, pattern, pattern, pattern, pattern);
|
||
}
|
||
where.push(`(${termClauses.join(" OR ")})`);
|
||
}
|
||
const rows = dbAll(
|
||
`SELECT kc.*, kd.title AS document_title, kd.source_type, kd.language, kd.scope_mode,
|
||
kd.rights_status, kd.risk_json,
|
||
kd.project_id, kd.organization_id, kd.workspace_id, kd.updated_at
|
||
FROM knowledge_chunks kc
|
||
JOIN knowledge_documents kd ON kd.id = kc.document_id
|
||
WHERE ${where.join(" AND ")}
|
||
ORDER BY kd.updated_at DESC, kc.chunk_index ASC
|
||
LIMIT ?`,
|
||
[...queryParams, Math.max(limit * 8, 80)]
|
||
);
|
||
const ranked = rows
|
||
.map((row) => {
|
||
const chunk = normalizeKnowledgeChunk(row);
|
||
const score = scoreKnowledgeChunk(chunk, terms);
|
||
return {
|
||
...chunk,
|
||
score,
|
||
snippet: snippetFor(chunk.content, terms),
|
||
citationKey: ""
|
||
};
|
||
})
|
||
.filter((item) => !terms.length || item.score > 0)
|
||
.sort((left, right) => right.score - left.score || right.updatedAt.localeCompare(left.updatedAt) || left.chunkIndex - right.chunkIndex)
|
||
.slice(0, limit)
|
||
.map((item, index) => ({ ...item, citationKey: `K${index + 1}` }));
|
||
const documentIds = new Set(ranked.map((item) => item.documentId));
|
||
return {
|
||
query,
|
||
scopeMode,
|
||
sourceType,
|
||
total: ranked.length,
|
||
results: ranked,
|
||
summary: {
|
||
documents: documentIds.size,
|
||
chunks: ranked.length,
|
||
tokenEstimate: ranked.reduce((sum, item) => sum + Number(item.tokenEstimate || 0), 0),
|
||
types: ranked.reduce((accumulator, item) => ({ ...accumulator, [item.chunkType]: (accumulator[item.chunkType] || 0) + 1 }), {})
|
||
}
|
||
};
|
||
}
|
||
|
||
function knowledgeChunksForIds(context, chunkIds) {
|
||
const ids = unique(chunkIds).slice(0, 80);
|
||
if (!ids.length) return [];
|
||
const { clause, params } = scopedKnowledgeQuery(context);
|
||
const rows = dbAll(
|
||
`SELECT kc.*, kd.title AS document_title, kd.source_type, kd.language, kd.scope_mode,
|
||
kd.rights_status, kd.risk_json,
|
||
kd.project_id, kd.organization_id, kd.workspace_id, kd.updated_at
|
||
FROM knowledge_chunks kc
|
||
JOIN knowledge_documents kd ON kd.id = kc.document_id
|
||
WHERE kc.id IN (${placeholders(ids)}) AND ${clause}
|
||
ORDER BY kd.updated_at DESC, kc.chunk_index ASC`,
|
||
[...ids, ...params]
|
||
).map(normalizeKnowledgeChunk);
|
||
const byId = new Map(rows.map((row) => [row.id, row]));
|
||
const ordered = ids.map((id) => byId.get(id)).filter(Boolean);
|
||
if (ordered.length !== ids.length) throw httpError(422, "knowledge_chunk_scope_invalid", "知识片段不存在，或不属于当前组织/工作区/项目作用域", { requested: ids.length, matched: ordered.length });
|
||
return ordered;
|
||
}
|
||
|
||
function trimChunkForBudget(chunk, remainingTokens) {
|
||
const allowedTokens = Math.max(40, Number(remainingTokens || 0));
|
||
if (chunk.tokenEstimate <= allowedTokens) return chunk;
|
||
const allowedChars = Math.max(120, Math.floor(allowedTokens * 1.8));
|
||
return {
|
||
...chunk,
|
||
content: `${chunk.content.slice(0, allowedChars).trim()}…`,
|
||
tokenEstimate: approxTokens(chunk.content.slice(0, allowedChars))
|
||
};
|
||
}
|
||
|
||
function selectPackChunks(chunks, maxTokens) {
|
||
const selected = [];
|
||
let tokenEstimate = 0;
|
||
for (const chunk of chunks) {
|
||
const remaining = maxTokens - tokenEstimate;
|
||
if (remaining <= 0) break;
|
||
const candidate = selected.length ? chunk : trimChunkForBudget(chunk, remaining);
|
||
if (candidate.tokenEstimate > remaining && selected.length) continue;
|
||
selected.push(candidate);
|
||
tokenEstimate += Number(candidate.tokenEstimate || 0);
|
||
}
|
||
return { chunks: selected, tokenEstimate };
|
||
}
|
||
|
||
function packPromptContext(name, chunks, citations, governance = {}) {
|
||
const blocks = chunks.map((chunk, index) => {
|
||
const citation = citations[index];
|
||
return [
|
||
`## [${citation.key}] ${chunk.heading || `片段 ${chunk.chunkIndex}`}`,
|
||
`来源：《${chunk.documentTitle}》 / ${chunk.sourceType || "素材"} / chunk ${chunk.chunkIndex} / rights=${citation.rightsStatus || "needs-evidence"} / risk=${citation.riskStatus || "unscanned"}`,
|
||
`内容：${chunk.content}`
|
||
].join("\n");
|
||
});
|
||
return [
|
||
`# 知识库上下文包：${name}`,
|
||
"使用要求：基于引用素材做原创改编；保留人物、道具、地点和时间线连续性；生成画面仍必须是一张完整单画面，不得输出多格、拼图或分屏。",
|
||
`治理摘要：${governance.status || "unscanned"}；未批准/需复核片段 ${governance.reviewCount || 0}；阻断片段 ${governance.blockingCount || 0}。`,
|
||
...blocks
|
||
].join("\n\n");
|
||
}
|
||
|
||
function packPayload(context, body = {}, chunks, tokenEstimate, persist) {
|
||
const name = String(body.name || body.title || (body.query ? `检索包：${body.query}` : "知识库上下文包")).trim().slice(0, 80);
|
||
const query = String(body.query || "").trim().slice(0, 120);
|
||
const scopeMode = String(body.scopeMode || body.scope_mode || (context.project ? "project" : "workspace")).trim();
|
||
const maxTokens = Math.max(100, Math.min(20000, Number(body.maxTokens || body.max_tokens || 1600)));
|
||
const sourceType = String(body.sourceType || body.source_type || "mixed").trim();
|
||
const citations = chunks.map((chunk, index) => ({
|
||
key: `K${index + 1}`,
|
||
documentId: chunk.documentId,
|
||
documentTitle: chunk.documentTitle,
|
||
chunkId: chunk.id,
|
||
chunkIndex: chunk.chunkIndex,
|
||
heading: chunk.heading,
|
||
sourceType: chunk.sourceType,
|
||
scopeMode: chunk.scopeMode,
|
||
rightsStatus: chunk.rightsStatus || "needs-evidence",
|
||
riskStatus: chunk.riskStatus || chunk.risk?.status || "unscanned",
|
||
projectId: chunk.projectId || null
|
||
}));
|
||
const compactChunks = chunks.map((chunk, index) => ({
|
||
citationKey: citations[index].key,
|
||
id: chunk.id,
|
||
documentId: chunk.documentId,
|
||
documentTitle: chunk.documentTitle,
|
||
chunkIndex: chunk.chunkIndex,
|
||
chunkType: chunk.chunkType,
|
||
heading: chunk.heading,
|
||
content: chunk.content,
|
||
tokenEstimate: chunk.tokenEstimate,
|
||
keywords: chunk.keywords,
|
||
entities: chunk.entities,
|
||
rightsStatus: chunk.rightsStatus || "needs-evidence",
|
||
riskStatus: chunk.riskStatus || chunk.risk?.status || "unscanned"
|
||
}));
|
||
const governance = summarizePackGovernance(chunks);
|
||
return {
|
||
schema: "ai-drama.knowledge-context-pack.v1",
|
||
id: String(body.id || makeId(persist ? "knowledge-pack" : "knowledge-pack-preview")),
|
||
name,
|
||
query,
|
||
sourceType,
|
||
scopeMode: ["workspace", "project"].includes(scopeMode) ? scopeMode : "workspace",
|
||
projectId: scopeMode === "project" ? context.project?.id || "" : "",
|
||
maxTokens,
|
||
tokenEstimate,
|
||
selectedCount: compactChunks.length,
|
||
chunkIds: compactChunks.map((chunk) => chunk.id),
|
||
citations,
|
||
chunks: compactChunks,
|
||
promptContext: packPromptContext(name, chunks, citations, governance),
|
||
governance,
|
||
metadata: body.metadata && typeof body.metadata === "object" ? { ...body.metadata, governance } : { governance }
|
||
};
|
||
}
|
||
|
||
export function createKnowledgeContextPack(context, body = {}, options = {}) {
|
||
const persist = options.persist !== false;
|
||
requirePermission(context, persist ? "script:edit" : "script:read");
|
||
if (persist) requireEntitlement(context, "limit.knowledge_context_packs", 1);
|
||
const maxTokens = Math.max(100, Math.min(20000, Number(body.maxTokens || body.max_tokens || 1600)));
|
||
const chunkIds = Array.isArray(body.chunkIds || body.chunk_ids) ? body.chunkIds || body.chunk_ids : [];
|
||
const sourceChunks = chunkIds.length
|
||
? knowledgeChunksForIds(context, chunkIds)
|
||
: searchKnowledge(context, { ...body, limit: Math.max(1, Math.min(40, Number(body.limit || 12))) }).results;
|
||
if (!sourceChunks.length) throw httpError(404, "knowledge_context_empty", "没有可用于上下文包的知识片段");
|
||
const selected = selectPackChunks(sourceChunks, maxTokens);
|
||
const blocked = selected.chunks.filter((chunk) => ["rejected", "expired"].includes(chunk.rightsStatus || "") || chunk.risk?.status === "blocked");
|
||
if (blocked.length) {
|
||
throw httpError(409, "knowledge_context_blocked", "选中的知识片段包含版权不可用或风险阻断素材，不能创建生产上下文包", {
|
||
blocked: blocked.map((chunk) => ({ id: chunk.id, documentId: chunk.documentId, rightsStatus: chunk.rightsStatus, riskStatus: chunk.risk?.status || "unscanned" }))
|
||
});
|
||
}
|
||
const containsProjectScopedChunk = selected.chunks.some((chunk) => chunk.scopeMode === "project" || chunk.projectId);
|
||
const requestedScopeMode = String(body.scopeMode || body.scope_mode || "workspace").trim();
|
||
const effectiveScopeMode = containsProjectScopedChunk ? "project" : requestedScopeMode;
|
||
if (effectiveScopeMode === "project" && !context.project) throw httpError(400, "knowledge_project_required", "项目级上下文包必须绑定当前项目");
|
||
const pack = packPayload(context, { ...body, maxTokens, scopeMode: effectiveScopeMode }, selected.chunks, selected.tokenEstimate, persist);
|
||
if (persist) {
|
||
const timestamp = now();
|
||
withTransaction(() => {
|
||
dbRun(
|
||
`INSERT INTO knowledge_context_packs(
|
||
id, organization_id, workspace_id, project_id, scope_mode, name, query, source_type, max_tokens,
|
||
token_estimate, chunk_ids_json, citations_json, chunks_json, prompt_context, status,
|
||
metadata_json, created_by, created_at, updated_at
|
||
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, ?)`,
|
||
[
|
||
pack.id,
|
||
context.organization.id,
|
||
context.workspace.id,
|
||
pack.scopeMode === "project" ? context.project?.id || null : null,
|
||
pack.scopeMode,
|
||
pack.name,
|
||
pack.query,
|
||
pack.sourceType,
|
||
pack.maxTokens,
|
||
pack.tokenEstimate,
|
||
JSON.stringify(pack.chunkIds),
|
||
JSON.stringify(pack.citations),
|
||
JSON.stringify(pack.chunks),
|
||
pack.promptContext,
|
||
JSON.stringify(pack.metadata),
|
||
context.user.id,
|
||
timestamp,
|
||
timestamp
|
||
]
|
||
);
|
||
});
|
||
addAudit({ context, action: "knowledge.context_pack.created", targetType: "knowledge_context_pack", targetId: pack.id, metadata: { name: pack.name, chunkCount: pack.selectedCount, tokenEstimate: pack.tokenEstimate } });
|
||
addUsage({ context, kind: "knowledge-context-pack", units: pack.selectedCount, unitName: "chunks", metadata: { packId: pack.id, tokenEstimate: pack.tokenEstimate } });
|
||
}
|
||
return { pack, packs: persist ? listKnowledgeContextPacks(context).packs : undefined };
|
||
}
|
||
|
||
export function listKnowledgeContextPacks(context) {
|
||
requirePermission(context, "script:read");
|
||
const { clause, params } = scopedKnowledgePackQuery(context);
|
||
const rows = dbAll(
|
||
`SELECT *
|
||
FROM knowledge_context_packs kcp
|
||
WHERE ${clause} AND kcp.status = 'active'
|
||
ORDER BY kcp.updated_at DESC, kcp.created_at DESC
|
||
LIMIT 80`,
|
||
params
|
||
).map(serializeContextPackRow);
|
||
return {
|
||
packs: rows,
|
||
summary: {
|
||
total: rows.length,
|
||
chunks: rows.reduce((sum, item) => sum + (item.chunkIds?.length || 0), 0),
|
||
tokenEstimate: rows.reduce((sum, item) => sum + Number(item.tokenEstimate || 0), 0)
|
||
}
|
||
};
|
||
}
|
||
|
||
export function getKnowledgeContextPack(context, packId) {
|
||
requirePermission(context, "script:read");
|
||
const { clause, params } = scopedKnowledgePackQuery(context);
|
||
const row = dbGet(
|
||
`SELECT *
|
||
FROM knowledge_context_packs kcp
|
||
WHERE kcp.id = ? AND ${clause}`,
|
||
[packId, ...params]
|
||
);
|
||
if (!row) throw httpError(404, "knowledge_context_pack_not_found", "知识库上下文包不存在或不属于当前作用域", { packId });
|
||
return { pack: serializeContextPackRow(row) };
|
||
}
|
||
|
||
export function materializeKnowledgeContextPack(context, packId, body = {}) {
|
||
requirePermission(context, "script:edit");
|
||
requireProjectWritable(context);
|
||
if (!context.project) throw httpError(400, "project_required", "上下文包送入剧本工厂时必须绑定项目");
|
||
const { pack } = getKnowledgeContextPack(context, packId);
|
||
const chunks = Array.isArray(pack.chunks) ? pack.chunks : [];
|
||
assertPackGovernanceUsable(pack);
|
||
if (!chunks.length) throw httpError(422, "knowledge_context_pack_empty", "上下文包没有可导入的片段");
|
||
const content = [
|
||
`# ${pack.name}`,
|
||
pack.citations?.length ? `引用：${pack.citations.map((item) => `[${item.key}]《${item.documentTitle}》/${item.heading}`).join("；")}` : "",
|
||
...chunks.map((chunk) => [`## ${chunk.citationKey || ""} ${chunk.heading || chunk.id}`.trim(), chunk.content].join("\n"))
|
||
].filter(Boolean).join("\n\n");
|
||
const scriptImport = importScript(context, {
|
||
title: String(body.title || `${pack.name} · 剧本草稿`).trim(),
|
||
sourceType: `知识库上下文包/${pack.sourceType || "mixed"}`,
|
||
content,
|
||
episodeId: body.episodeId || undefined,
|
||
episodeTitle: body.episodeTitle || undefined,
|
||
metadata: {
|
||
origin: "knowledge_context_pack",
|
||
knowledgePackId: pack.id,
|
||
knowledgePackName: pack.name,
|
||
knowledgeChunkIds: pack.chunkIds || [],
|
||
knowledgeCitations: pack.citations || [],
|
||
knowledgeGovernance: pack.governance || {}
|
||
}
|
||
});
|
||
addAudit({ context, action: "knowledge.context_pack.materialized", targetType: "knowledge_context_pack", targetId: packId, metadata: { scriptDocumentId: scriptImport.document?.id || "", chunkCount: chunks.length } });
|
||
return {
|
||
sourcePack: pack,
|
||
importedScript: scriptImport.document,
|
||
graph: scriptImport.graph
|
||
};
|
||
}
|
||
|
||
export function resolveKnowledgeContextForJob(context, body = {}) {
|
||
const packId = String(body.knowledgePackId || body.knowledge_pack_id || "").trim();
|
||
const inlinePack = body.knowledgePack && typeof body.knowledgePack === "object" ? body.knowledgePack : null;
|
||
const chunkIds = Array.isArray(body.knowledgeChunkIds || body.knowledge_chunk_ids) ? body.knowledgeChunkIds || body.knowledge_chunk_ids : [];
|
||
const query = String(body.knowledgeQuery || body.knowledge_query || "").trim();
|
||
if (!packId && !inlinePack && !chunkIds.length && !query) return null;
|
||
requirePermission(context, "script:read");
|
||
if (packId) {
|
||
const pack = getKnowledgeContextPack(context, packId).pack;
|
||
assertPackGovernanceUsable(pack);
|
||
return pack;
|
||
}
|
||
if (inlinePack) {
|
||
return {
|
||
schema: "ai-drama.knowledge-context-pack.v1",
|
||
id: String(inlinePack.id || "inline-knowledge-pack"),
|
||
name: String(inlinePack.name || "内联知识库上下文包"),
|
||
tokenEstimate: Number(inlinePack.tokenEstimate || 0),
|
||
chunkIds: Array.isArray(inlinePack.chunkIds) ? inlinePack.chunkIds : [],
|
||
citations: Array.isArray(inlinePack.citations) ? inlinePack.citations : [],
|
||
chunks: Array.isArray(inlinePack.chunks) ? inlinePack.chunks : [],
|
||
promptContext: String(inlinePack.promptContext || ""),
|
||
sourceType: String(inlinePack.sourceType || "inline"),
|
||
scopeMode: String(inlinePack.scopeMode || "workspace")
|
||
};
|
||
}
|
||
return createKnowledgeContextPack(context, {
|
||
name: body.knowledgePackName || body.knowledge_pack_name || (query ? `任务上下文：${query}` : "任务上下文包"),
|
||
query,
|
||
chunkIds,
|
||
maxTokens: body.knowledgeMaxTokens || body.knowledge_max_tokens || 1600,
|
||
sourceType: body.knowledgeSourceType || body.knowledge_source_type || "mixed",
|
||
scopeMode: body.knowledgeScopeMode || body.knowledge_scope_mode || "workspace",
|
||
metadata: { transient: true, jobKind: body.kind || "" }
|
||
}, { persist: false }).pack;
|
||
}
|
||
|
||
export function importKnowledgeDocument(context, body = {}) {
|
||
requirePermission(context, "script:edit");
|
||
requireEntitlement(context, "limit.knowledge_documents", 1);
|
||
const content = String(body.content || "").replace(/\r/g, "").trim();
|
||
if (content.length < 30) throw httpError(400, "knowledge_content_required", "导入知识库的文本至少需要 30 个字符");
|
||
const scopeMode = String(body.scopeMode || body.scope_mode || "workspace").trim();
|
||
if (!["workspace", "project"].includes(scopeMode)) throw httpError(400, "knowledge_scope_invalid", "知识库作用域只能是 workspace 或 project");
|
||
if (scopeMode === "project" && !context.project) throw httpError(400, "knowledge_project_required", "项目级知识库必须绑定当前项目");
|
||
const analysis = analyzeKnowledgeText(content);
|
||
const title = String(body.title || analysis.chapters[0]?.title || "未命名素材").trim();
|
||
if (!title) throw httpError(400, "knowledge_title_required", "知识库标题不能为空");
|
||
const sourceType = String(body.sourceType || body.source_type || "novel").trim();
|
||
const language = String(body.language || "zh-CN").trim();
|
||
const metadata = body.metadata && typeof body.metadata === "object" ? body.metadata : {};
|
||
const rightsStatus = normalizeRightsStatus(body.rightsStatus || body.rights_status || metadata.rightsStatus || metadata.rights);
|
||
const provenance = normalizeProvenance(body, metadata);
|
||
const tags = normalizeTags(body.tags || metadata.tags || []);
|
||
const risk = scanKnowledgeGovernance({ title, content, sourceType, rightsStatus, provenance, tags });
|
||
const id = String(body.id || makeId("knowledge"));
|
||
const timestamp = now();
|
||
withTransaction(() => {
|
||
dbRun(
|
||
`INSERT INTO knowledge_documents(
|
||
id, organization_id, workspace_id, project_id, scope_mode, title, source_type, language,
|
||
content, status, rights_status, summary, analysis_json, provenance_json, tags_json, risk_json,
|
||
metadata_json, current_version_number, created_by, created_at, updated_at
|
||
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'indexed', ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?)`,
|
||
[id, context.organization.id, context.workspace.id, scopeMode === "project" ? context.project?.id || null : null, scopeMode, title, sourceType, language, content, rightsStatus, analysis.summary, JSON.stringify({ ...analysis, chunks: undefined }), JSON.stringify(provenance), JSON.stringify(tags), JSON.stringify(risk), JSON.stringify(metadata), context.user.id, timestamp, timestamp]
|
||
);
|
||
writeKnowledgeChunks(id, analysis.chunks, timestamp);
|
||
insertKnowledgeVersion(context, {
|
||
id,
|
||
title,
|
||
sourceType,
|
||
language,
|
||
content,
|
||
summary: analysis.summary,
|
||
analysis,
|
||
provenance,
|
||
tags,
|
||
risk,
|
||
metadata
|
||
}, 1, timestamp, { action: "ingest" });
|
||
});
|
||
addAudit({ context, action: "knowledge.document.ingested", targetType: "knowledge_document", targetId: id, metadata: { title, scopeMode, sourceType, chunkCount: analysis.chunkCount, rightsStatus, riskStatus: risk.status, riskScore: risk.score } });
|
||
addUsage({ context, kind: "knowledge-ingest", units: analysis.chunkCount, unitName: "chunks", metadata: { documentId: id, sourceType, parser: analysis.parser } });
|
||
return { document: knowledgeDocumentDetail(context, id), summary: listKnowledgeDocuments(context).summary };
|
||
}
|
||
|
||
export function updateKnowledgeDocument(context, documentId, body = {}) {
|
||
requirePermission(context, "script:edit");
|
||
const existing = knowledgeDocumentDetail(context, documentId);
|
||
if (!existing) throw httpError(404, "knowledge_document_not_found", "知识库文档不存在或不属于当前作用域", { documentId });
|
||
const title = body.title === undefined ? existing.title : String(body.title || "").trim();
|
||
if (!title) throw httpError(400, "knowledge_title_required", "知识库标题不能为空");
|
||
const sourceType = body.sourceType === undefined && body.source_type === undefined ? existing.sourceType || existing.source_type || "novel" : String(body.sourceType || body.source_type || "novel").trim();
|
||
const language = body.language === undefined ? existing.language || "zh-CN" : String(body.language || "zh-CN").trim();
|
||
const content = body.content === undefined ? existing.content || "" : String(body.content || "").replace(/\r/g, "").trim();
|
||
if (content.length < 30) throw httpError(400, "knowledge_content_required", "知识库正文至少需要 30 个字符");
|
||
const status = normalizeDocumentStatus(body.status, existing.status || "indexed");
|
||
const rightsInput = body.rightsStatus ?? body.rights_status ?? existing.rightsStatus;
|
||
const rightsStatus = normalizeRightsStatus(rightsInput);
|
||
const provenance = normalizeProvenance(body, existing.provenance);
|
||
const tags = body.tags === undefined ? existing.tags || [] : normalizeTags(body.tags);
|
||
const metadata = body.metadata && typeof body.metadata === "object" ? { ...(existing.metadata || {}), ...body.metadata } : existing.metadata || {};
|
||
const contentChanged = content !== existing.content || title !== existing.title || sourceType !== (existing.sourceType || existing.source_type) || language !== existing.language;
|
||
const analysis = contentChanged ? analyzeKnowledgeText(content) : existing.analysis || analyzeKnowledgeText(content);
|
||
const risk = scanKnowledgeGovernance({ title, content, sourceType, rightsStatus, provenance, tags });
|
||
const versionNumber = nextKnowledgeVersionNumber(documentId);
|
||
const timestamp = now();
|
||
withTransaction(() => {
|
||
dbRun(
|
||
`UPDATE knowledge_documents
|
||
SET title = ?, source_type = ?, language = ?, content = ?, status = ?, rights_status = ?,
|
||
summary = ?, analysis_json = ?, provenance_json = ?, tags_json = ?, risk_json = ?,
|
||
metadata_json = ?, current_version_number = ?, updated_at = ?
|
||
WHERE id = ?`,
|
||
[title, sourceType, language, content, status, rightsStatus, analysis.summary, JSON.stringify({ ...analysis, chunks: undefined }), JSON.stringify(provenance), JSON.stringify(tags), JSON.stringify(risk), JSON.stringify(metadata), versionNumber, timestamp, documentId]
|
||
);
|
||
if (contentChanged) {
|
||
dbRun("DELETE FROM knowledge_chunks WHERE document_id = ?", [documentId]);
|
||
writeKnowledgeChunks(documentId, analysis.chunks, timestamp);
|
||
}
|
||
insertKnowledgeVersion(context, {
|
||
id: documentId,
|
||
title,
|
||
sourceType,
|
||
language,
|
||
content,
|
||
summary: analysis.summary,
|
||
analysis,
|
||
provenance,
|
||
tags,
|
||
risk,
|
||
metadata
|
||
}, versionNumber, timestamp, { action: "update", contentChanged });
|
||
});
|
||
addAudit({ context, action: "knowledge.document.updated", targetType: "knowledge_document", targetId: documentId, metadata: { title, versionNumber, contentChanged, rightsStatus, riskStatus: risk.status } });
|
||
return { document: knowledgeDocumentDetail(context, documentId), summary: listKnowledgeDocuments(context).summary };
|
||
}
|
||
|
||
export function reviewKnowledgeDocument(context, documentId, body = {}) {
|
||
const decision = normalizeGovernanceDecision(body.decision);
|
||
if (["approved", "rejected"].includes(decision)) requirePermission(context, "compliance:manage");
|
||
else if (!hasPermission(context, "script:edit") && !hasPermission(context, "compliance:manage") && !hasPermission(context, "asset:edit")) {
|
||
throw httpError(403, "permission_denied", "缺少提交素材治理证据的权限", { permission: "script:edit" });
|
||
}
|
||
const existing = knowledgeDocumentDetail(context, documentId);
|
||
if (!existing) throw httpError(404, "knowledge_document_not_found", "知识库文档不存在或不属于当前作用域", { documentId });
|
||
const requestedRights = body.rightsStatus ?? body.rights_status;
|
||
const rightsStatus = normalizeRightsStatus(requestedRights || (decision === "approved" ? "approved" : decision === "rejected" ? "rejected" : "submitted"));
|
||
const provenance = normalizeProvenance(body, existing.provenance);
|
||
if (body.evidenceRef || body.evidence_ref) provenance.evidenceRef = String(body.evidenceRef || body.evidence_ref || "").trim();
|
||
const tags = body.tags === undefined ? existing.tags || [] : normalizeTags(body.tags);
|
||
const risk = scanKnowledgeGovernance({
|
||
title: existing.title,
|
||
content: existing.content,
|
||
sourceType: existing.sourceType || existing.source_type,
|
||
rightsStatus,
|
||
provenance,
|
||
tags
|
||
});
|
||
const reviewId = String(body.id || makeId("knowledge-review"));
|
||
const timestamp = now();
|
||
withTransaction(() => {
|
||
dbRun(
|
||
`INSERT INTO knowledge_governance_reviews(
|
||
id, document_id, organization_id, workspace_id, project_id, decision, rights_status,
|
||
risk_status, notes, evidence_ref, provenance_json, risk_json, reviewer_user_id, created_at
|
||
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
||
[
|
||
reviewId,
|
||
documentId,
|
||
context.organization.id,
|
||
context.workspace.id,
|
||
existing.projectId || null,
|
||
decision,
|
||
rightsStatus,
|
||
risk.status,
|
||
String(body.notes || "").trim(),
|
||
provenance.evidenceRef || "",
|
||
JSON.stringify(provenance),
|
||
JSON.stringify(risk),
|
||
context.user.id,
|
||
timestamp
|
||
]
|
||
);
|
||
dbRun(
|
||
`UPDATE knowledge_documents
|
||
SET rights_status = ?, provenance_json = ?, tags_json = ?, risk_json = ?, updated_at = ?
|
||
WHERE id = ?`,
|
||
[rightsStatus, JSON.stringify(provenance), JSON.stringify(tags), JSON.stringify(risk), timestamp, documentId]
|
||
);
|
||
});
|
||
addAudit({ context, action: `knowledge.document.review.${decision}`, targetType: "knowledge_document", targetId: documentId, metadata: { reviewId, rightsStatus, riskStatus: risk.status, evidenceRef: provenance.evidenceRef || "" } });
|
||
return { document: knowledgeDocumentDetail(context, documentId), review: latestKnowledgeReview(documentId), summary: listKnowledgeDocuments(context).summary };
|
||
}
|
||
|
||
export function archiveKnowledgeDocument(context, documentId) {
|
||
requirePermission(context, "script:edit");
|
||
const existing = knowledgeDocumentDetail(context, documentId);
|
||
if (!existing) throw httpError(404, "knowledge_document_not_found", "知识库文档不存在或不属于当前作用域", { documentId });
|
||
const timestamp = now();
|
||
dbRun("UPDATE knowledge_documents SET status = 'archived', updated_at = ? WHERE id = ?", [timestamp, documentId]);
|
||
addAudit({ context, action: "knowledge.document.archived", targetType: "knowledge_document", targetId: documentId, metadata: { previousStatus: existing.status } });
|
||
return { document: knowledgeDocumentDetail(context, documentId), summary: listKnowledgeDocuments(context).summary };
|
||
}
|
||
|
||
export function restoreKnowledgeDocument(context, documentId) {
|
||
requirePermission(context, "script:edit");
|
||
const existing = knowledgeDocumentDetail(context, documentId);
|
||
if (!existing) throw httpError(404, "knowledge_document_not_found", "知识库文档不存在或不属于当前作用域", { documentId });
|
||
const timestamp = now();
|
||
dbRun("UPDATE knowledge_documents SET status = 'indexed', updated_at = ? WHERE id = ?", [timestamp, documentId]);
|
||
addAudit({ context, action: "knowledge.document.restored", targetType: "knowledge_document", targetId: documentId, metadata: { previousStatus: existing.status } });
|
||
return { document: knowledgeDocumentDetail(context, documentId), summary: listKnowledgeDocuments(context).summary };
|
||
}
|
||
|
||
export function listKnowledgeDocumentVersions(context, documentId) {
|
||
requirePermission(context, "script:read");
|
||
const existing = knowledgeDocumentDetail(context, documentId);
|
||
if (!existing) throw httpError(404, "knowledge_document_not_found", "知识库文档不存在或不属于当前作用域", { documentId });
|
||
const versions = dbAll(
|
||
`SELECT *
|
||
FROM knowledge_document_versions
|
||
WHERE document_id = ?
|
||
ORDER BY version_number DESC`,
|
||
[documentId]
|
||
).map(serializeKnowledgeVersionRow);
|
||
return { document: existing, versions };
|
||
}
|
||
|
||
export function restoreKnowledgeDocumentVersion(context, documentId, versionKey) {
|
||
requirePermission(context, "script:edit");
|
||
const existing = knowledgeDocumentDetail(context, documentId);
|
||
if (!existing) throw httpError(404, "knowledge_document_not_found", "知识库文档不存在或不属于当前作用域", { documentId });
|
||
const version = dbGet(
|
||
`SELECT *
|
||
FROM knowledge_document_versions
|
||
WHERE document_id = ? AND (id = ? OR CAST(version_number AS TEXT) = ?)
|
||
LIMIT 1`,
|
||
[documentId, String(versionKey), String(versionKey)]
|
||
);
|
||
if (!version) throw httpError(404, "knowledge_version_not_found", "知识库文档版本不存在", { documentId, versionKey });
|
||
const serialized = serializeKnowledgeVersionRow(version);
|
||
const analysis = analyzeKnowledgeText(serialized.content);
|
||
const risk = scanKnowledgeGovernance({
|
||
title: serialized.title,
|
||
content: serialized.content,
|
||
sourceType: serialized.sourceType,
|
||
rightsStatus: existing.rightsStatus,
|
||
provenance: serialized.provenance,
|
||
tags: serialized.tags
|
||
});
|
||
const versionNumber = nextKnowledgeVersionNumber(documentId);
|
||
const timestamp = now();
|
||
withTransaction(() => {
|
||
dbRun(
|
||
`UPDATE knowledge_documents
|
||
SET title = ?, source_type = ?, language = ?, content = ?, summary = ?, analysis_json = ?,
|
||
provenance_json = ?, tags_json = ?, risk_json = ?, current_version_number = ?, status = 'indexed', updated_at = ?
|
||
WHERE id = ?`,
|
||
[serialized.title, serialized.sourceType, serialized.language, serialized.content, analysis.summary, JSON.stringify({ ...analysis, chunks: undefined }), JSON.stringify(serialized.provenance), JSON.stringify(serialized.tags), JSON.stringify(risk), versionNumber, timestamp, documentId]
|
||
);
|
||
dbRun("DELETE FROM knowledge_chunks WHERE document_id = ?", [documentId]);
|
||
writeKnowledgeChunks(documentId, analysis.chunks, timestamp);
|
||
insertKnowledgeVersion(context, {
|
||
id: documentId,
|
||
title: serialized.title,
|
||
sourceType: serialized.sourceType,
|
||
language: serialized.language,
|
||
content: serialized.content,
|
||
summary: analysis.summary,
|
||
analysis,
|
||
provenance: serialized.provenance,
|
||
tags: serialized.tags,
|
||
risk,
|
||
metadata: { ...serialized.metadata, restoredFromVersion: serialized.versionNumber }
|
||
}, versionNumber, timestamp, { action: "restore-version", restoredFromVersion: serialized.versionNumber, restoredFromVersionId: serialized.id });
|
||
});
|
||
addAudit({ context, action: "knowledge.document.version_restored", targetType: "knowledge_document", targetId: documentId, metadata: { restoredFromVersion: serialized.versionNumber, newVersionNumber: versionNumber } });
|
||
return { document: knowledgeDocumentDetail(context, documentId), versions: listKnowledgeDocumentVersions(context, documentId).versions };
|
||
}
|
||
|
||
export function materializeKnowledgeDocument(context, documentId, body = {}) {
|
||
requirePermission(context, "script:edit");
|
||
requireProjectWritable(context);
|
||
if (!context.project) throw httpError(400, "project_required", "把知识库文档送入剧本工厂时必须绑定项目");
|
||
const document = knowledgeDocumentDetail(context, documentId);
|
||
if (!document) throw httpError(404, "knowledge_document_not_found", "知识库文档不存在或不属于当前作用域", { documentId });
|
||
assertKnowledgeDocumentUsable(document);
|
||
const selectedChunkIds = Array.isArray(body.chunkIds) ? new Set(body.chunkIds.map((item) => String(item))) : null;
|
||
const selectedChunks = selectedChunkIds ? document.chunks.filter((chunk) => selectedChunkIds.has(chunk.id)) : document.chunks;
|
||
const content = selectedChunks.length ? selectedChunks.map((chunk) => `${chunk.heading}\n${chunk.content}`.trim()).join("\n\n") : document.content;
|
||
const scriptImport = importScript(context, {
|
||
title: String(body.title || `${document.title} · 剧本草稿`).trim(),
|
||
sourceType: `知识库/${document.source_type || "novel"}`,
|
||
content,
|
||
episodeId: body.episodeId || undefined,
|
||
episodeTitle: body.episodeTitle || undefined,
|
||
metadata: {
|
||
origin: "knowledge_document",
|
||
knowledgeDocumentId: document.id,
|
||
knowledgeDocumentTitle: document.title,
|
||
knowledgeChunkIds: selectedChunks.map((chunk) => chunk.id),
|
||
knowledgeGovernance: {
|
||
rightsStatus: document.rightsStatus || document.rights_status || "needs-evidence",
|
||
riskStatus: document.risk?.status || document.riskStatus || "unscanned"
|
||
}
|
||
}
|
||
});
|
||
addAudit({ context, action: "knowledge.document.materialized", targetType: "knowledge_document", targetId: documentId, metadata: { scriptDocumentId: scriptImport.document?.id || "", chunkCount: selectedChunks.length } });
|
||
return {
|
||
sourceDocument: document,
|
||
importedScript: scriptImport.document,
|
||
graph: scriptImport.graph
|
||
};
|
||
}
|