dsh-thesis 1.0.0

package/lib/paper/commands.js

@@ -0,0 +1,84 @@
+/**
+ * 斜杠命令：/thesis-status 与 /thesis-decide。
+ *
+ * 注：DSH 命令名只允许 [a-z][a-z0-9_-]*，因此使用 kebab-case
+ * （DESIGN.md 中的 /thesis:status 在此修正为 /thesis-status）。
+ * 其余命令（/thesis-lit、/thesis-check、/thesis-build）随 M2/M4 工具一并注册。
+ */
+import { writeFile } from 'node:fs/promises';
+import { runDecision } from "./tools/decision.js";
+import { runLitSearch } from "./tools/lit.js";
+import { runProgress } from "./tools/progress.js";
+import { buildSummary, runBuild } from "./tools/build.js";
+import { runCheck } from "./tools/check.js";
+function cwdOf(invocation) {
+    return invocation.agent.session.header.cwd;
+}
+async function safe(work) {
+    try {
+        return { kind: 'success', text: await work() };
+    }
+    catch (error) {
+        return { kind: 'error', text: error instanceof Error ? error.message : String(error) };
+    }
+}
+export function statusCommand(fs) {
+    return {
+        name: 'thesis-status',
+        description: '查看毕业设计进度台账：当前阶段、人工关卡、任务状态',
+        async handler(invocation) {
+            return await safe(async () => runProgress(fs, { action: 'report' }, cwdOf(invocation), invocation.signal));
+        },
+    };
+}
+export function decideCommand(fs) {
+    return {
+        name: 'thesis-decide',
+        description: '记录一条关键决定（内容/理由/备选），写入决定日志',
+        input: { hint: '决定内容' },
+        async handler(invocation) {
+            const content = invocation.rawInput.trim();
+            if (content === '') {
+                return { kind: 'error', text: '用法：/thesis-decide <决定内容>。内容不能为空。' };
+            }
+            return await safe(async () => runDecision(fs, { content }, cwdOf(invocation), invocation.signal));
+        },
+    };
+}
+export function litCommand(fs) {
+    return {
+        name: 'thesis-lit',
+        description: '从真实学术数据库检索文献（结果写入检索缓存与审计记录）',
+        input: { hint: '检索关键词' },
+        async handler(invocation) {
+            const query = invocation.rawInput.trim();
+            if (query === '') {
+                return { kind: 'error', text: '用法：/thesis-lit <关键词>。例如 /thesis-lit 目标检测 小目标' };
+            }
+            return await safe(async () => runLitSearch(fs, { query, limit: 5 }, cwdOf(invocation), invocation.signal, fetch));
+        },
+    };
+}
+export function checkCommand(fs) {
+    return {
+        name: 'thesis-check',
+        description: '全文综合检查：引用/字数/图表/术语/模板，报告写入 08-合规/',
+        async handler(invocation) {
+            return await safe(async () => runCheck(fs, cwdOf(invocation), invocation.signal));
+        },
+    };
+}
+export function buildCommand(fs) {
+    return {
+        name: 'thesis-build',
+        description: '构建论文.docx（优先 pandoc + 学校模板，否则内置过渡引擎）',
+        async handler(invocation) {
+            return await safe(async () => {
+                const outcome = await runBuild(fs, {}, cwdOf(invocation), invocation.signal, async (absPath, data) => {
+                    await writeFile(absPath, data);
+                });
+                return buildSummary(outcome);
+            });
+        },
+    };
+}

package/lib/paper/lib/aicheck.d.ts

@@ -0,0 +1,38 @@
+/**
+ * AI 味自查（thesis_stylecheck 的核心）：确定性启发式扫描。
+ *
+ * 六条规则，全部基于文本特征，可复现：
+ * 1. 模板套话（"综上所述/众所周知/随着…的发展"等清单）
+ * 2. 空洞结论句（"具有一定的意义"类）
+ * 3. 自我暴露（正文出现 AI/大语言模型等表述 —— 错误级）
+ * 4. 翻译腔（"被用于/进行了…的/一个…的过程"等）
+ * 5. 句式单一（连续 3 段以上以同一开头）
+ * 6. 无锚点段落（长段落无数字、无引用、无图表、无具体对象）
+ *
+ * 本工具是"自查"，不是"证明"：命中项给出改写方向，最终是否修改由用户
+ * 在 G2/G4 关卡决定。改写建议与 thesis-writing 技能 §4 的去 AI 味规则一致。
+ */
+export interface AiFindingItem {
+    readonly excerpt: string;
+    readonly line: number;
+}
+export interface AiFinding {
+    readonly rule: string;
+    readonly level: 'error' | 'warn';
+    readonly advice: string;
+    readonly items: readonly AiFindingItem[];
+}
+export interface AiChapterReport {
+    readonly chapter: string;
+    readonly findings: readonly AiFinding[];
+}
+export interface AiSelfcheckReport {
+    readonly chapters: readonly AiChapterReport[];
+    readonly totalFindings: number;
+    readonly errorCount: number;
+}
+export declare function runAiSelfcheck(chapters: readonly {
+    name: string;
+    text: string;
+}[]): AiSelfcheckReport;
+export declare function renderAiSelfcheck(report: AiSelfcheckReport, now?: Date): string;

package/lib/paper/lib/aicheck.js

@@ -0,0 +1,241 @@
+/**
+ * AI 味自查（thesis_stylecheck 的核心）：确定性启发式扫描。
+ *
+ * 六条规则，全部基于文本特征，可复现：
+ * 1. 模板套话（"综上所述/众所周知/随着…的发展"等清单）
+ * 2. 空洞结论句（"具有一定的意义"类）
+ * 3. 自我暴露（正文出现 AI/大语言模型等表述 —— 错误级）
+ * 4. 翻译腔（"被用于/进行了…的/一个…的过程"等）
+ * 5. 句式单一（连续 3 段以上以同一开头）
+ * 6. 无锚点段落（长段落无数字、无引用、无图表、无具体对象）
+ *
+ * 本工具是"自查"，不是"证明"：命中项给出改写方向，最终是否修改由用户
+ * 在 G2/G4 关卡决定。改写建议与 thesis-writing 技能 §4 的去 AI 味规则一致。
+ */
+const CLICHES = [
+    '综上所述', '总而言之', '众所周知', '值得注意的是', '不难发现', '显而易见',
+    '在当今', '近年来', '意义重大', '迫在眉睫', '不可或缺', '日益重要', '突飞猛进', '日新月异',
+];
+const RULES = [
+    {
+        name: '模板套话',
+        level: 'warn',
+        advice: '删除或改写为具体内容：套话不携带信息，是 AI 检测的重点信号。',
+        test: (text) => {
+            const hits = new Set();
+            for (const phrase of CLICHES) {
+                if (text.includes(phrase))
+                    hits.add(`"${phrase}"`);
+            }
+            for (const m of text.matchAll(/随着[\u4e00-\u9fff]{2,20}的(发展|进步|普及|应用)/g))
+                hits.add(`"${m[0]}"`);
+            return hits.size > 0 ? [...hits] : null;
+        },
+    },
+    {
+        name: '空洞结论句',
+        level: 'warn',
+        advice: '"具有一定的意义"没有信息量。改为具体结论：解决了什么问题、带来了什么可度量的效果。',
+        test: (text) => {
+            const hits = new Set();
+            for (const m of text.matchAll(/(具有|有着)(一定的|重要的|较大的|深远的)?(意义|价值|作用)/g))
+                hits.add(m[0]);
+            return hits.size > 0 ? [...hits] : null;
+        },
+    },
+    {
+        name: '自我暴露',
+        level: 'error',
+        advice: '论文正文不得出现 AI 工具表述。删除该句；若确需说明工具使用，放在致谢或按学校规定位置，并先与导师沟通。',
+        test: (text) => {
+            const hits = new Set();
+            for (const m of text.matchAll(/作为\s*AI|人工智能助手|大语言模型|大型语言模型|语言模型生成|ChatGPT|由\s*AI\s*(生成|撰写|完成)/gi))
+                hits.add(m[0]);
+            return hits.size > 0 ? [...hits] : null;
+        },
+    },
+    {
+        name: '翻译腔',
+        level: 'warn',
+        advice: '改为自然中文表达："被用于"→"用于/用来"；"进行了…的研究"→"研究了…"；"一个…的过程"→直接说动作。',
+        test: (text) => {
+            const hits = new Set();
+            const patterns = [
+                /被用于/g,
+                /对[\u4e00-\u9fff]{2,20}进行了/g,
+                /进行了[\u4e00-\u9fff]{2,20}的/g,
+                /一个[\u4e00-\u9fff]{2,10}的过程/g,
+                /基于[\u4e00-\u9fff]{2,20}的基础(之上)?/g,
+                /进行(深入)?的(研究|分析|探讨)/g,
+            ];
+            for (const pattern of patterns) {
+                for (const m of text.matchAll(pattern))
+                    hits.add(m[0]);
+            }
+            return hits.size > 0 ? [...hits] : null;
+        },
+    },
+    {
+        name: '句式单一',
+        level: 'warn',
+        advice: '连续多段以同一短语开头会暴露模式化生成。变换段落开头方式：从结论、对象、转折或数据切入。',
+        paragraphs: (paragraphs) => {
+            const items = [];
+            let runStart = 0;
+            let runKey = '';
+            let runCount = 0;
+            const flush = () => {
+                if (runCount >= 3) {
+                    items.push({
+                        excerpt: `连续 ${runCount} 段以"${runKey.slice(0, 12)}"开头`,
+                        line: paragraphs[runStart].line,
+                    });
+                }
+            };
+            for (const para of paragraphs) {
+                const key = para.text.slice(0, 6);
+                if (key === runKey) {
+                    runCount += 1;
+                }
+                else {
+                    flush();
+                    runKey = key;
+                    runStart = paragraphs.indexOf(para);
+                    runCount = 1;
+                }
+            }
+            flush();
+            return items;
+        },
+    },
+];
+// ---------------------------------------------------------------------------
+// 段落切分与扫描
+// ---------------------------------------------------------------------------
+function bodyParagraphs(chapterText) {
+    const paragraphs = [];
+    const lines = chapterText.split('\n');
+    let start = -1;
+    const flush = (end) => {
+        if (start >= 0) {
+            const block = lines.slice(start, end).map(l => l.trim()).filter(l => l !== '' && !l.startsWith('|') && !l.startsWith('- ')).join('');
+            if (block.length > 20)
+                paragraphs.push({ text: block, line: start + 1 });
+        }
+    };
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (line.trim() === '') {
+            flush(i);
+            start = -1;
+            continue;
+        }
+        if (/^#{1,6}\s/.test(line)) {
+            flush(i);
+            start = -1;
+            continue;
+        }
+        if (start < 0)
+            start = i;
+    }
+    flush(lines.length);
+    return paragraphs;
+}
+function lineOf(text, needle) {
+    const idx = text.indexOf(needle);
+    if (idx < 0)
+        return 0;
+    return text.slice(0, idx).split('\n').length;
+}
+function scanChapter(chapterText) {
+    const findings = [];
+    const paragraphs = bodyParagraphs(chapterText);
+    const paragraphText = paragraphs.map(p => p.text).join('\n');
+    for (const rule of RULES) {
+        let items = [];
+        if (rule.test !== undefined) {
+            const hits = rule.test(paragraphText);
+            if (hits !== null) {
+                items = hits.slice(0, 8).map(hit => ({ excerpt: hit, line: lineOf(chapterText, hit) }));
+            }
+        }
+        if (rule.paragraphs !== undefined) {
+            items = [...items, ...rule.paragraphs(paragraphs)];
+        }
+        if (items.length > 0) {
+            findings.push({ rule: rule.name, level: rule.level, advice: rule.advice, items });
+        }
+    }
+    // 无锚点段落（独立规则，需要逐段判断）
+    const anchorless = paragraphs.filter(para => {
+        const cjk = (para.text.match(/[\u4e00-\u9fff]/g) ?? []).length;
+        if (cjk < 100)
+            return false;
+        const hasNumber = /\d/.test(para.text);
+        const hasCitation = /\[\d/.test(para.text);
+        const hasFigure = /[图表]\s*\d+-\d+/.test(para.text);
+        const hasConcrete = /系统|模块|数据|实验|测试|本文|本系统|方法|算法|模型|接口|数据库|页面|功能/.test(para.text);
+        return !hasNumber && !hasCitation && !hasFigure && !hasConcrete;
+    });
+    if (anchorless.length > 0) {
+        findings.push({
+            rule: '无锚点段落',
+            level: 'warn',
+            advice: '长段落没有任何具体锚点（数字/引用/图表/具体对象），是"泛泛而谈"的信号。落到本课题的具体模块、数据或现象上，或拆分改写。',
+            items: anchorless.slice(0, 5).map(para => ({ excerpt: para.text.slice(0, 40), line: para.line })),
+        });
+    }
+    return findings;
+}
+export function runAiSelfcheck(chapters) {
+    const chapterReports = chapters.map(chapter => ({ chapter: chapter.name, findings: scanChapter(chapter.text) }));
+    let total = 0;
+    let errors = 0;
+    for (const report of chapterReports) {
+        for (const finding of report.findings) {
+            total += finding.items.length;
+            if (finding.level === 'error')
+                errors += finding.items.length;
+        }
+    }
+    return { chapters: chapterReports, totalFindings: total, errorCount: errors };
+}
+export function renderAiSelfcheck(report, now = new Date()) {
+    const lines = [];
+    lines.push('# AI 味自查报告');
+    lines.push('');
+    lines.push(`> 工具：thesis_stylecheck；生成时间：${now.toISOString()}`);
+    lines.push('> 本报告是启发式自查，不是检测结论；命中项请结合 thesis-writing 技能 §4 逐条改写。');
+    lines.push('');
+    lines.push('## 总览');
+    lines.push('');
+    lines.push(`- 命中：${report.totalFindings} 处；其中错误级 ${report.errorCount} 处`);
+    lines.push(`- 错误级（自我暴露）必须处理；警告级逐条判断后改写`);
+    lines.push('');
+    const withFindings = report.chapters.filter(c => c.findings.length > 0);
+    if (withFindings.length === 0) {
+        lines.push('## 各章明细');
+        lines.push('');
+        lines.push('全部章节未命中任何规则。仍需注意：启发式检查无法覆盖全部 AI 特征，最终以学校检测结果为准。');
+    }
+    for (const chapter of withFindings) {
+        lines.push(`## ${chapter.chapter}`);
+        lines.push('');
+        for (const finding of chapter.findings) {
+            lines.push(`### ${finding.level === 'error' ? '✗' : '⚠'} ${finding.rule}（${finding.items.length} 处）`);
+            lines.push('');
+            for (const item of finding.items) {
+                lines.push(`- 第 ${item.line} 行附近：${item.excerpt}`);
+            }
+            lines.push('');
+            lines.push(`改写建议：${finding.advice}`);
+            lines.push('');
+        }
+    }
+    lines.push('## 自查结论（用户填写）');
+    lines.push('');
+    lines.push('- [ ] 我已逐条处理上述命中项，并对全文做过一轮人工通读与修改');
+    lines.push('- [ ] 确认人：________ 日期：________');
+    lines.push('');
+    return lines.join('\n');
+}

package/lib/paper/lib/bibtex.d.ts

@@ -0,0 +1,21 @@
+/**
+ * BibTeX 构造与解析（文献库 02-文献/refs.bib）。
+ *
+ * 只从 LitRecord（真实检索记录）构造条目；不做任何"凭空补全"。
+ * 条目使用 UTF-8（pandoc/biblatex/biber 现代工具链默认支持）。
+ */
+import type { LitRecord } from './lit-api.ts';
+export interface BibEntry {
+    readonly key: string;
+    readonly entry: string;
+}
+export declare function bibKeyFor(record: LitRecord): string;
+export declare function buildBibtex(record: LitRecord, keyOverride?: string): BibEntry;
+/** 提取 refs.bib 中已用的 key 集合。 */
+export declare function parseBibKeys(bib: string): Set<string>;
+/** 按出现顺序提取 key（GB/T 7714 顺序编码制下，条目顺序即引用编号）。 */
+export declare function parseBibKeysOrdered(bib: string): string[];
+/** 提取 refs.bib 中已收录的 DOI（小写），用于去重。 */
+export declare function parseBibDois(bib: string): Set<string>;
+/** 给 key 加字母后缀直到不与现有 key 冲突。 */
+export declare function dedupeKey(key: string, existing: ReadonlySet<string>): string;

package/lib/paper/lib/bibtex.js

@@ -0,0 +1,114 @@
+/**
+ * BibTeX 构造与解析（文献库 02-文献/refs.bib）。
+ *
+ * 只从 LitRecord（真实检索记录）构造条目；不做任何"凭空补全"。
+ * 条目使用 UTF-8（pandoc/biblatex/biber 现代工具链默认支持）。
+ */
+function sanitizeKeyPart(text) {
+    // 保留拉丁字母/数字与中日韩汉字（UTF-8 bib key 由现代工具链支持）。
+    return text
+        .toLowerCase()
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replace(/[^a-z0-9\u4e00-\u9fff]+/g, '');
+}
+/** 作者姓氏：英文取最后一个词；中文（无空格）整体保留。 */
+function authorKeyPart(author) {
+    const trimmed = author.trim();
+    const parts = trimmed.split(/\s+/);
+    const last = parts[parts.length - 1] ?? trimmed;
+    const s = sanitizeKeyPart(last);
+    return s === '' ? sanitizeKeyPart(trimmed) : s;
+}
+function titleKeyPart(title) {
+    // 中文标题：取全部汉字的前 4 个（稳定、确定性；冲突由 dedupeKey 处理）。
+    const cjk = (title.match(/[\u4e00-\u9fff]+/g) ?? []).join('');
+    if (cjk !== '')
+        return cjk.slice(0, 4);
+    const words = title.split(/\s+/).filter(w => !/^(a|an|the|on|of|for|and)$/i.test(w));
+    for (const word of words) {
+        const s = sanitizeKeyPart(word);
+        if (s !== '')
+            return s;
+    }
+    return 'paper';
+}
+export function bibKeyFor(record) {
+    const author = record.authors[0] !== undefined ? authorKeyPart(record.authors[0]) : 'anon';
+    const year = record.year ?? '';
+    const title = titleKeyPart(record.title);
+    return `${author}${year}${title}`.slice(0, 40);
+}
+function authorsField(authors) {
+    return authors.map(a => a.trim()).filter(a => a !== '').join(' and ');
+}
+function optionalFields(record, extra) {
+    const fields = [];
+    for (const [name, value] of extra) {
+        if (value !== undefined && value !== '')
+            fields.push(`  ${name} = {${value}}`);
+    }
+    if (record.doi !== undefined && record.doi !== '')
+        fields.push(`  doi = {${record.doi}}`);
+    if (record.url !== undefined && record.url !== '')
+        fields.push(`  url = {${record.url}}`);
+    return fields;
+}
+export function buildBibtex(record, keyOverride) {
+    const key = keyOverride ?? bibKeyFor(record);
+    const author = authorsField(record.authors);
+    const year = record.year ?? '';
+    let entry;
+    switch (record.type) {
+        case 'article':
+            entry = `@article{${key},\n  author = {${author}},\n  title = {${record.title}},\n  journal = {${record.venue || 'unknown'}},\n  year = {${year}},\n${optionalFields(record, []).join(',\n')}\n}`;
+            break;
+        case 'inproceedings':
+            entry = `@inproceedings{${key},\n  author = {${author}},\n  title = {${record.title}},\n  booktitle = {${record.venue || 'unknown'}},\n  year = {${year}},\n${optionalFields(record, []).join(',\n')}\n}`;
+            break;
+        case 'book':
+            entry = `@book{${key},\n  author = {${author}},\n  title = {${record.title}},\n  publisher = {${record.venue || 'unknown'}},\n  year = {${year}},\n${optionalFields(record, []).join(',\n')}\n}`;
+            break;
+        case 'phdthesis':
+            entry = `@phdthesis{${key},\n  author = {${author}},\n  title = {${record.title}},\n  school = {${record.venue || 'unknown'}},\n  year = {${year}},\n${optionalFields(record, []).join(',\n')}\n}`;
+            break;
+        case 'misc':
+            entry = `@misc{${key},\n  author = {${author}},\n  title = {${record.title}},\n  howpublished = {${record.venue || 'Preprint'}},\n  year = {${year}},\n${optionalFields(record, []).join(',\n')}\n}`;
+            break;
+    }
+    return { key, entry };
+}
+/** 提取 refs.bib 中已用的 key 集合。 */
+export function parseBibKeys(bib) {
+    return new Set(parseBibKeysOrdered(bib));
+}
+/** 按出现顺序提取 key（GB/T 7714 顺序编码制下，条目顺序即引用编号）。 */
+export function parseBibKeysOrdered(bib) {
+    const keys = [];
+    for (const m of bib.matchAll(/^@\w+\s*\{\s*([^,\s]+)/gm)) {
+        if (m[1] !== undefined)
+            keys.push(m[1]);
+    }
+    return keys;
+}
+/** 提取 refs.bib 中已收录的 DOI（小写），用于去重。 */
+export function parseBibDois(bib) {
+    const dois = new Set();
+    for (const m of bib.matchAll(/doi\s*=\s*[{"]([^}"\s]+)[}"]/gi)) {
+        if (m[1] !== undefined)
+            dois.add(m[1].toLowerCase());
+    }
+    return dois;
+}
+/** 给 key 加字母后缀直到不与现有 key 冲突。 */
+export function dedupeKey(key, existing) {
+    if (!existing.has(key))
+        return key;
+    const suffix = 'abcdefghijklmnopqrstuvwxyz';
+    for (const letter of suffix) {
+        const candidate = `${key}${letter}`;
+        if (!existing.has(candidate))
+            return candidate;
+    }
+    return `${key}x${Math.random().toString(36).slice(2, 5)}`;
+}

package/lib/paper/lib/check.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 全文综合检查（thesis_check 的核心），五项确定性检查：
+ * 1. 引用双向一致：文中引用 ↔ refs.bib（顺序编码制下编号=条目顺序）
+ * 2. 字数统计：每章 CJK 字数 vs 目标区间 + 全文合计
+ * 3. 图/表编号：每章章号与连续性（复用 review 的检查器）
+ * 4. 术语定义先于使用：缩写（ABBR）第一次出现必须在定义"全称（ABBR）"之后
+ * 5. 学校模板探测：assets/学校模板 有无模板文件
+ */
+import { CHAPTER_META } from './layout.ts';
+export interface CheckChapter {
+    readonly name: string;
+    readonly no: number;
+    readonly text: string;
+}
+export interface CheckInput {
+    readonly chapters: readonly CheckChapter[];
+    readonly bibText: string;
+    readonly templateFiles: readonly string[];
+}
+export interface CheckSection {
+    readonly id: string;
+    readonly title: string;
+    readonly ok: boolean;
+    readonly lines: readonly string[];
+}
+export interface CheckReport {
+    readonly sections: readonly CheckSection[];
+    readonly allOk: boolean;
+}
+export declare function runGlobalCheck(input: CheckInput): CheckReport;
+export declare function renderCheckReport(report: CheckReport): string;
+export { CHAPTER_META };