@akemi-mio/creativity 0.0.0-stage → 0.1.0

package/dist/HypothesisGenerator.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HypothesisGenerator = void 0;
+const CreativityPrompt_1 = require("./CreativityPrompt");
+const TemplateLibrary_1 = require("./TemplateLibrary");
+const LocalModelService_1 = require("./LocalModelService");
+const random_1 = require("@akemi-mio/core/utils/random");
+const Logger_1 = require("@akemi-mio/core/logger/Logger");
+/**
+ * HypothesisGenerator — 将概念组合转化为可验证的假设
+ *
+ * 四级生成链（逐级降级）：
+ *   远程 LLM → 本地模型 (transformers.js) → TemplateLibrary (30+ 模式) → 原始模板兜底
+ */
+class HypothesisGenerator {
+    idCounter = 0;
+    rng;
+    chatJson;
+    templateLib;
+    localModel;
+    rotationSeed = 0;
+    callCount = 0;
+    constructor(chatJson, seed, rotationSeed = 0) {
+        this.chatJson = chatJson;
+        this.rng = (0, random_1.resolveRandom)(seed);
+        this.templateLib = new TemplateLibrary_1.TemplateLibrary(seed);
+        this.localModel = new LocalModelService_1.LocalModelService();
+        this.rotationSeed = rotationSeed;
+    }
+    /**
+     * 从概念组合生成假设 — 远程 LLM → 本地模型 → TemplateLibrary → 模板兜底
+     *
+     * 四级 fallback 链：
+     *   1. 远程 LLM           (高质，但 30s 超时、网络依赖)
+     *   2. 本地 transformers.js (进程内，~1s，无网络依赖)
+     *   3. TemplateLibrary    (30+ 模式，类型感知，零延迟)
+     *   4. 原始模板           (5 个硬编码，终极兜底)
+     */
+    async generate(combos, sources, 
+    /** 梦境模式使用更高温度 */
+    dreamMode = false, 
+    /** 外部信号 — 不参与配对，作为审视视角注入 LLM */
+    externalSignals = [], 
+    /** 显式技法；缺省走五技法轮换（rotationSeed + 调用次数） */
+    method) {
+        if (combos.length === 0)
+            return [];
+        const technique = method ?? (0, CreativityPrompt_1.pickTechnique)(this.rotationSeed + this.callCount);
+        this.callCount += 1;
+        // 第一级：远程 LLM 驱动生成
+        const llmResults = await this.tryLLM(sources, combos, dreamMode, externalSignals, technique);
+        if (llmResults.length > 0) {
+            return this.tag(llmResults.map((r) => ({
+                id: `hyp_${Date.now()}_${++this.idCounter}_${this.rng().toString(36).slice(2, 4)}`,
+                title: r.title,
+                idea: r.idea,
+                expectedBenefit: r.expectedBenefit,
+                risk: r.risk,
+                sourceLabels: r.sourceLabels,
+                sourceDetails: this.buildSourceDetails(r.sourceLabels, sources),
+                novelty: Math.max(10, Math.min(100, r.novelty)),
+                feasibility: Math.max(10, Math.min(100, r.feasibility)),
+                impact: Math.max(10, Math.min(100, r.impact)),
+                status: 'draft',
+                createdAt: Date.now(),
+            })), technique);
+        }
+        // 第二级：本地 transformers.js 模型
+        if (this.localModel.isEnabled) {
+            (0, Logger_1.log)('INFO', 'hypothesis_fallback_local', { count: combos.length });
+            const localResults = await this.tryLocalModel(sources, combos, dreamMode, technique);
+            if (localResults.length > 0) {
+                return this.tag(localResults.map((r) => ({
+                    id: `hyp_local_${Date.now()}_${++this.idCounter}_${this.rng().toString(36).slice(2, 4)}`,
+                    title: r.title,
+                    idea: r.idea,
+                    expectedBenefit: r.expectedBenefit,
+                    risk: r.risk,
+                    sourceLabels: r.sourceLabels,
+                    sourceDetails: this.buildSourceDetails(r.sourceLabels, sources),
+                    novelty: Math.max(10, Math.min(100, r.novelty)),
+                    feasibility: Math.max(10, Math.min(100, r.feasibility)),
+                    impact: Math.max(10, Math.min(100, r.impact)),
+                    status: 'draft',
+                    createdAt: Date.now(),
+                })), technique);
+            }
+        }
+        // 第二/三级失败 → 记录日志
+        (0, Logger_1.log)('INFO', 'hypothesis_fallback_templates', { count: combos.length });
+        // 第三级：TemplateLibrary (30+ 类型感知模板)
+        const tplResults = [];
+        for (const combo of combos) {
+            const h = this.templateLib.generate(combo, sources);
+            if (h)
+                tplResults.push(h);
+        }
+        if (tplResults.length > 0) {
+            return this.tag(tplResults, technique);
+        }
+        // 第四级：原始模板兜底
+        (0, Logger_1.log)('WARN', 'hypothesis_fallback_legacy', { count: combos.length });
+        return this.tag(combos.map((combo) => this.templateFallback(combo)), technique);
+    }
+    /**
+     * 调 LLM 生成创意
+     */
+    async tryLLM(sources, combos, dreamMode, externalSignals = [], technique = '') {
+        // 限制输入量，避免超 token
+        const topCombos = combos.slice(0, dreamMode ? 5 : 3);
+        const comboInfo = topCombos.map((c) => ({
+            sources: c.sources,
+            description: c.description,
+        }));
+        const prompt = (0, CreativityPrompt_1.buildCreativityPrompt)(sources, comboInfo, externalSignals);
+        try {
+            const result = await this.chatJson(prompt, {
+                system: (0, CreativityPrompt_1.buildSystemPrompt)(technique),
+                temperature: dreamMode ? 1.0 : 0.8,
+                timeoutMs: 60000,
+                // 输出无界会顶满超时（M2）：生成上限 1200 tokens
+                maxTokens: 1200,
+            });
+            if (result.error) {
+                (0, Logger_1.log)('WARN', 'hypothesis_llm_error', { error: result.error });
+                return [];
+            }
+            const ideas = Array.isArray(result.data) ? result.data : [];
+            // 验证基本格式
+            return ideas.filter((i) => typeof i.title === 'string' &&
+                typeof i.idea === 'string' &&
+                Array.isArray(i.sourceLabels) &&
+                typeof i.novelty === 'number' &&
+                this.hasRelevanceJustification(i));
+        }
+        catch (err) {
+            (0, Logger_1.log)('ERROR', 'hypothesis_llm_exception', { error: String(err) });
+            return [];
+        }
+    }
+    /**
+     * 调本地 transformers.js 模型生成创意
+     */
+    async tryLocalModel(sources, combos, dreamMode, technique = '') {
+        const topCombos = combos.slice(0, dreamMode ? 3 : 2);
+        const comboInfo = topCombos.map((c) => ({
+            sources: c.sources,
+            description: c.description,
+        }));
+        const prompt = (0, CreativityPrompt_1.buildCreativityPrompt)(sources, comboInfo);
+        const result = await this.localModel.generate(prompt, {
+            system: (0, CreativityPrompt_1.buildSystemPrompt)(technique),
+            temperature: dreamMode ? 0.8 : 0.6,
+            maxTokens: dreamMode ? 1024 : 768,
+        });
+        if (result.error) {
+            (0, Logger_1.log)('WARN', 'hypothesis_local_error', { error: result.error });
+            return [];
+        }
+        const ideas = Array.isArray(result.data) ? result.data : [];
+        return ideas.filter((i) => typeof i.title === 'string' &&
+            typeof i.idea === 'string' &&
+            Array.isArray(i.sourceLabels) &&
+            typeof i.novelty === 'number' &&
+            this.hasRelevanceJustification(i));
+    }
+    hasRelevanceJustification(i) {
+        const relevance = typeof i.relevance === 'string' ? i.relevance.trim() : '';
+        return relevance.length >= 10;
+    }
+    /** 记录本轮使用的轮换技法（idea.generate 的 provenance.technique 字段写它）。 */
+    tag(hypotheses, technique) {
+        return hypotheses.map((h) => ({ ...h, technique }));
+    }
+    /** 根据 sourceLabels 构建来源深度详情（默认 shallow） */
+    buildSourceDetails(labels, sources) {
+        const byName = new Map(sources.map((s) => [s.name, s.sourceDepth ?? 'shallow']));
+        return labels.map((name) => ({ name, depth: byName.get(name) ?? 'shallow' }));
+    }
+    /**
+     * 模板 fallback — 从旧实现保留
+     */
+    templateFallback(combo) {
+        const [a, b] = combo.sources;
+        const hash = this.stableHash(a, b);
+        const idx = hash % TEMPLATES.length;
+        const t = TEMPLATES[idx];
+        return {
+            id: `hyp_fb_${Date.now()}_${++this.idCounter}_${this.rng().toString(36).slice(2, 4)}`,
+            title: t.title(a, b),
+            idea: t.idea(a, b),
+            expectedBenefit: t.expectedBenefit,
+            risk: t.risk,
+            sourceLabels: [a, b],
+            sourceDetails: [a, b].map((name) => ({ name, depth: 'shallow' })),
+            novelty: 50 + Math.round(this.rng() * 30),
+            feasibility: 40 + Math.round(this.rng() * 30),
+            impact: 50 + Math.round(this.rng() * 25),
+            status: 'draft',
+            createdAt: Date.now(),
+        };
+    }
+    stableHash(a, b) {
+        let h = 0;
+        const s = a + '|' + b;
+        for (let i = 0; i < s.length; i++) {
+            h = (h << 5) - h + s.charCodeAt(i);
+            h = h & h;
+        }
+        return Math.abs(h);
+    }
+}
+exports.HypothesisGenerator = HypothesisGenerator;
+const TEMPLATES = [
+    {
+        title: (a, b) => `${a} 驱动的 ${b}`,
+        idea: (a, b) => `将「${a}」的核心机制作为「${b}」的新输入维度`,
+        expectedBenefit: '解锁之前被忽视的新能力组合',
+        risk: '组合可能引入不必要的复杂度',
+    },
+    {
+        title: (a, b) => `基于 ${a} 的 ${b} 增强`,
+        idea: (a, b) => `让「${a}」和「${b}」通过一个共享接口互相增强`,
+        expectedBenefit: '系统灵活性提升，涌现新的行为模式',
+        risk: '两个概念耦合后难以单独演进',
+    },
+    {
+        title: (a, b) => `${a} × ${b} 混合系统`,
+        idea: (a, b) => `借鉴「${a}」的设计哲学重新思考「${b}」的实现`,
+        expectedBenefit: '减少重复逻辑，提升模块间信息复用',
+        risk: '可能存在隐含的语义冲突',
+    },
+    {
+        title: (a, b) => `从 ${a} 到 ${b} 的抽象跳跃`,
+        idea: (a, b) => `在「${a}」的基础上构建「${b}」的新抽象层`,
+        expectedBenefit: '降低认知负载，统一概念模型',
+        risk: '抽象层过多影响 runtime 性能',
+    },
+    {
+        title: (a, b) => `${a} 视角下的 ${b} 重构`,
+        idea: (a, b) => `将「${a}」的某一种能力移植到「${b}」的上下文中`,
+        expectedBenefit: '架构更优雅，扩展点增加',
+        risk: '预期收益不确定，需要实验验证',
+    },
+];
+// 保留旧文件中的 PATTERN_LIBRARY 作为参考，但不再使用

package/dist/IdeaGenerator.d.ts

@@ -0,0 +1,51 @@
+import type { CreativitySource, ConceptCombo, Hypothesis, CreativeIdea, Strategy, ExternalSignal } from './types';
+/**
+ * IdeaGenerator — 创造力引擎的核心编排器
+ *
+ * 流程：
+ * 1. Source Gathering — 从多个来源收集"概念"
+ * 2. Concept Mixing — 随机配对重组（规则引擎，保留）
+ * 3. Hypothesis Generation — 将组合转化为假设（LLM 驱动，new）
+ * 4. Experiment Planning — 为假设生成验证方案（规则引擎，保留）
+ */
+export declare class IdeaGenerator {
+    private mixer;
+    private hypothesisGen;
+    private experimentPlanner;
+    private rng;
+    private temperature;
+    /** 已探索过的配对 key 列表，传给 ConceptMixer 以降权 */
+    private exploredPairs;
+    constructor(chatJson: (userText: string, options?: {
+        system?: string;
+        temperature?: number;
+        timeoutMs?: number;
+        requestId?: string;
+    }) => Promise<{
+        data?: any;
+        error?: string;
+    }>, temperature?: number, seed?: number, rotationSeed?: number);
+    /**
+     * 完整一轮"灵感涌现"流程
+     * @param strategy 生成策略，约束 ConceptMixer 配对空间
+     */
+    generateIdeas(sources: CreativitySource[], maxIdeas?: number, strategy?: Strategy, externalSignals?: ExternalSignal[], method?: string): Promise<CreativeIdea[]>;
+    /**
+     * Dream Mode — 高随机性、跨时间跨度的"梦境"模式
+     */
+    dreamIdeas(recentSources: CreativitySource[], historicalCombos: ConceptCombo[], failedHypotheses: Hypothesis[], maxIdeas?: number, strategy?: Strategy): Promise<CreativeIdea[]>;
+    setTemperature(t: number): void;
+    /** 设置已探索过的配对，用于 ConceptMixer 降权 */
+    setExploredPairs(pairs: string[]): void;
+    /**
+     * 可行性/质量门禁 — 过滤明显不靠谱的想法
+     * - 可行性评分 >= 30 才保留
+     * - 想法描述至少 20 个字符（排除模板填空）
+     * - novelty > 80 但 feasibility < 40 的"可疑高新颖性"需要额外检查描述长度
+     */
+    private feasibilityGate;
+    /**
+     * 温度影响来源选择权重
+     */
+    private applyTemperature;
+}

package/dist/IdeaGenerator.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdeaGenerator = void 0;
+const ConceptMixer_1 = require("./ConceptMixer");
+const HypothesisGenerator_1 = require("./HypothesisGenerator");
+const ExperimentPlanner_1 = require("./ExperimentPlanner");
+const random_1 = require("@akemi-mio/core/utils/random");
+/**
+ * IdeaGenerator — 创造力引擎的核心编排器
+ *
+ * 流程：
+ * 1. Source Gathering — 从多个来源收集"概念"
+ * 2. Concept Mixing — 随机配对重组（规则引擎，保留）
+ * 3. Hypothesis Generation — 将组合转化为假设（LLM 驱动，new）
+ * 4. Experiment Planning — 为假设生成验证方案（规则引擎，保留）
+ */
+class IdeaGenerator {
+    mixer;
+    hypothesisGen;
+    experimentPlanner;
+    rng;
+    // 创造力温度：越高越随机，越低越保守
+    temperature = 0.3;
+    /** 已探索过的配对 key 列表，传给 ConceptMixer 以降权 */
+    exploredPairs = [];
+    constructor(chatJson, temperature = 0.3, seed, rotationSeed = 0) {
+        this.rng = (0, random_1.resolveRandom)(seed);
+        this.mixer = new ConceptMixer_1.ConceptMixer(seed);
+        this.hypothesisGen = new HypothesisGenerator_1.HypothesisGenerator(chatJson, seed, rotationSeed);
+        this.experimentPlanner = new ExperimentPlanner_1.ExperimentPlanner(seed);
+        this.temperature = temperature;
+    }
+    /**
+     * 完整一轮"灵感涌现"流程
+     * @param strategy 生成策略，约束 ConceptMixer 配对空间
+     */
+    async generateIdeas(sources, maxIdeas = 5, strategy = 'explore', externalSignals = [], method) {
+        if (sources.length < 2)
+            return [];
+        // 1. 随机扰动：温度越高，来源选择越随机
+        const activeSources = this.applyTemperature(sources);
+        // 2. 概念重组：按策略约束配对 + 打分
+        const scoredCombos = this.mixer.mix(activeSources, maxIdeas * 3, this.exploredPairs, strategy);
+        const combos = scoredCombos.map((c) => c.combo);
+        if (combos.length === 0)
+            return [];
+        // 3. 用 LLM 生成假设（外部信号作为审视视角注入，不参与配对）
+        const hypotheses = await this.hypothesisGen.generate(combos, activeSources, false, externalSignals, method);
+        // 4. 可行性/质量门禁（与 dream 模式同一套门槛）——此前只有梦境路径
+        //    过 feasibilityGate，主路径仅按 novelty 筛，可行性 0 分也能入库。
+        const feasible = this.feasibilityGate(hypotheses);
+        // 5. 策略感知的新颖性门禁 — stable 模式同类型配对新颖度天然偏低，
+        //    降低阈值避免误杀；signal 模式需要更高的新颖度才有价值
+        const noveltyThreshold = strategy === 'stable' ? 30 : strategy === 'signal' ? 40 : 35;
+        const novel = feasible.filter((h) => h.novelty >= noveltyThreshold);
+        // 6. 为每个假设生成实验方案
+        const ideas = novel.slice(0, maxIdeas).map((h) => ({
+            hypothesis: h,
+            experiment: this.experimentPlanner.plan(h),
+        }));
+        return ideas;
+    }
+    /**
+     * Dream Mode — 高随机性、跨时间跨度的"梦境"模式
+     */
+    async dreamIdeas(recentSources, historicalCombos, failedHypotheses, maxIdeas = 3, strategy = 'explore') {
+        // 梦境模式：提高温度，纳入失败历史，强制跨类型组合
+        const dreamTemperature = 0.8;
+        // 将失败方案转化为来源（高权重）
+        const failureSources = failedHypotheses.map((h) => ({
+            name: `失败:${h.title}`,
+            content: `${h.idea}\n风险:${h.risk}`,
+            type: 'failure',
+            weight: 0.8,
+        }));
+        const allSources = [
+            ...recentSources,
+            ...failureSources,
+            // 添加随机扰动源
+            {
+                name: `随机种子_${Date.now()}`,
+                content: this.rng().toString(36),
+                type: 'random',
+                weight: 0.3,
+            },
+        ];
+        // 用高温度混合
+        const activeSources = this.mixer.pickRandomSources(allSources, dreamTemperature, 4);
+        const scoredCombos = this.mixer.mix(activeSources, maxIdeas * 5, [], strategy);
+        const combos = scoredCombos.map((c) => c.combo);
+        if (combos.length === 0)
+            return [];
+        // 梦境模式：高温度 + dreamMode=true
+        const hypotheses = await this.hypothesisGen.generate(combos, activeSources, true);
+        const feasible = this.feasibilityGate(hypotheses);
+        const novel = feasible.filter((h) => h.novelty >= 50);
+        return novel.slice(0, maxIdeas).map((h) => ({
+            hypothesis: h,
+            experiment: this.experimentPlanner.plan(h),
+        }));
+    }
+    setTemperature(t) {
+        this.temperature = Math.max(0, Math.min(1, t));
+    }
+    /** 设置已探索过的配对，用于 ConceptMixer 降权 */
+    setExploredPairs(pairs) {
+        this.exploredPairs = pairs;
+    }
+    /**
+     * 可行性/质量门禁 — 过滤明显不靠谱的想法
+     * - 可行性评分 >= 30 才保留
+     * - 想法描述至少 20 个字符（排除模板填空）
+     * - novelty > 80 但 feasibility < 40 的"可疑高新颖性"需要额外检查描述长度
+     */
+    feasibilityGate(hypotheses) {
+        return hypotheses.filter((h) => {
+            if (h.feasibility < 30)
+                return false;
+            if (!h.idea || h.idea.length < 20)
+                return false;
+            if (h.novelty > 80 && h.feasibility < 40) {
+                if (!h.idea || h.idea.length < 60)
+                    return false;
+            }
+            return true;
+        });
+    }
+    /**
+     * 温度影响来源选择权重
+     */
+    applyTemperature(sources) {
+        if (this.temperature < 0.2) {
+            return [...sources].sort((a, b) => b.weight - a.weight).slice(0, 4);
+        }
+        if (this.temperature > 0.7) {
+            return sources.filter(() => this.rng() > 0.2);
+        }
+        return sources.filter((s) => {
+            if (s.weight > 0.7)
+                return true;
+            return this.rng() < 0.85;
+        });
+    }
+}
+exports.IdeaGenerator = IdeaGenerator;

package/dist/LocalModelService.d.ts

@@ -0,0 +1,38 @@
+/**
+ * LocalModelService — 用 transformers.js 在进程内跑小模型
+ *
+ * 零外部依赖，进程内运行，不需要 Ollama/Python/独立服务。
+ * 懒加载，优先加载项目目录下的模型文件（models/Xenova/...），
+ * 不存在则从 HuggingFace 下载。
+ *
+ * 已下载模型位置：
+ *   models/Xenova/Qwen2.5-0.5B-Instruct/
+ *
+ * 环境变量：
+ *   LOCAL_HYPOTHESIS_MODEL   — 模型 ID (默认 Xenova/Qwen2.5-0.5B-Instruct)
+ *   LOCAL_HYPOTHESIS_DISABLED — 设为 'true' 禁用本地模型
+ *   MODEL_CACHE_DIR           — 缓存目录，缺省自动探测
+ */
+export declare class LocalModelService {
+    private generator;
+    private loadAttempted;
+    private modelId;
+    constructor(modelId?: string);
+    get isEnabled(): boolean;
+    get isLoaded(): boolean;
+    /**
+     * 生成文本 — 兼容 chatJson 接口格式
+     */
+    generate(userText: string, options?: {
+        system?: string;
+        temperature?: number;
+        maxTokens?: number;
+    }): Promise<{
+        data?: any;
+        error?: string;
+    }>;
+    /**
+     * 尝试从生成文本中提取 JSON
+     */
+    private tryParse;
+}

package/dist/LocalModelService.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalModelService = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const Logger_1 = require("@akemi-mio/core/logger/Logger");
+/**
+ * LocalModelService — 用 transformers.js 在进程内跑小模型
+ *
+ * 零外部依赖，进程内运行，不需要 Ollama/Python/独立服务。
+ * 懒加载，优先加载项目目录下的模型文件（models/Xenova/...），
+ * 不存在则从 HuggingFace 下载。
+ *
+ * 已下载模型位置：
+ *   models/Xenova/Qwen2.5-0.5B-Instruct/
+ *
+ * 环境变量：
+ *   LOCAL_HYPOTHESIS_MODEL   — 模型 ID (默认 Xenova/Qwen2.5-0.5B-Instruct)
+ *   LOCAL_HYPOTHESIS_DISABLED — 设为 'true' 禁用本地模型
+ *   MODEL_CACHE_DIR           — 缓存目录，缺省自动探测
+ */
+class LocalModelService {
+    generator = null;
+    loadAttempted = false;
+    modelId;
+    constructor(modelId) {
+        this.modelId = modelId || process.env.LOCAL_HYPOTHESIS_MODEL || 'Xenova/Qwen2.5-0.5B-Instruct';
+    }
+    get isEnabled() {
+        return process.env.LOCAL_HYPOTHESIS_DISABLED !== 'true';
+    }
+    get isLoaded() {
+        return this.generator !== null;
+    }
+    /**
+     * 生成文本 — 兼容 chatJson 接口格式
+     */
+    async generate(userText, options) {
+        if (!this.isEnabled) {
+            return { error: 'local model disabled by env' };
+        }
+        // 测试环境下跳过实际模型加载
+        if (process.env.VITEST || process.env.NODE_ENV === 'test') {
+            return { error: 'local model disabled in test environment' };
+        }
+        // 懒加载模型
+        if (!this.generator) {
+            if (this.loadAttempted)
+                return { error: 'model previously failed to load' };
+            this.loadAttempted = true;
+            try {
+                (0, Logger_1.log)('INFO', 'local_model_loading', { model: this.modelId });
+                const { pipeline, env } = await import('@xenova/transformers');
+                // 优先使用项目目录下的本地模型
+                const modelsDir = await resolveModelsDir();
+                const localModelPath = (0, path_1.resolve)(modelsDir, this.modelId);
+                const hasLocalFiles = (0, fs_1.existsSync)(localModelPath);
+                if (hasLocalFiles) {
+                    env.localModelPath = modelsDir;
+                    (0, Logger_1.log)('INFO', 'local_model_use_cache', { path: localModelPath });
+                }
+                else {
+                    (0, Logger_1.log)('INFO', 'local_model_no_cache', { path: localModelPath });
+                }
+                this.generator = await pipeline('text-generation', this.modelId, {
+                    cache_dir: process.env.MODEL_CACHE_DIR,
+                });
+                (0, Logger_1.log)('INFO', 'local_model_loaded', { model: this.modelId, local: hasLocalFiles });
+            }
+            catch (err) {
+                (0, Logger_1.log)('WARN', 'local_model_load_failed', { model: this.modelId, error: err.message });
+                this.generator = null;
+                return { error: `local model load failed: ${err.message}` };
+            }
+        }
+        // 构造 prompts
+        const systemMsg = options?.system || '';
+        const chatTemplate = systemMsg
+            ? `<|im_start|>system\n${systemMsg}<|im_end|>\n<|im_start|>user\n${userText}<|im_end|>\n<|im_start|>assistant\n`
+            : `<|im_start|>user\n${userText}<|im_end|>\n<|im_start|>assistant\n`;
+        try {
+            const result = await this.generator(chatTemplate, {
+                max_new_tokens: options?.maxTokens || 768,
+                temperature: options?.temperature ?? 0.7,
+                do_sample: true,
+            });
+            const rawText = Array.isArray(result) ? result[0]?.generated_text : result?.generated_text;
+            if (!rawText)
+                return { error: 'empty generation' };
+            // 去掉输入部分，只取生成的文本
+            const generated = rawText.slice(chatTemplate.length).trim();
+            // 尝试解析 JSON
+            const parsed = this.tryParse(generated);
+            if (parsed) {
+                return { data: parsed };
+            }
+            return { error: `generated non-JSON: ${generated.slice(0, 100)}` };
+        }
+        catch (err) {
+            (0, Logger_1.log)('WARN', 'local_model_generation_error', { error: err.message });
+            return { error: `generation failed: ${err.message}` };
+        }
+    }
+    /**
+     * 尝试从生成文本中提取 JSON
+     */
+    tryParse(text) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            const match = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+            if (match) {
+                try {
+                    return JSON.parse(match[1].trim());
+                }
+                catch {
+                    // ignore
+                }
+            }
+            const arrMatch = text.match(/\[[\s\S]*\]/);
+            if (arrMatch) {
+                try {
+                    return JSON.parse(arrMatch[0]);
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        return null;
+    }
+}
+exports.LocalModelService = LocalModelService;
+/** 自动探测项目 models 目录 */
+async function resolveModelsDir() {
+    // Electron 环境
+    try {
+        const { app } = await import('electron');
+        // 优先项目目录（dev），回退到 userData/models（安装版）
+        if ((0, fs_1.existsSync)((0, path_1.resolve)(app.getAppPath(), 'models'))) {
+            return (0, path_1.resolve)(app.getAppPath(), 'models');
+        }
+        return (0, path_1.resolve)(app.getPath('userData'), 'models');
+    }
+    catch {
+        // not in Electron
+    }
+    // Node.js 开发环境：逐级向上找 models/
+    let dir = process.cwd();
+    for (let i = 0; i < 5; i++) {
+        const p = (0, path_1.resolve)(dir, 'models');
+        if ((0, fs_1.existsSync)(p))
+            return p;
+        const parent = (0, path_1.resolve)(dir, '@akemi-mio/main');
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // fallback: CWD/models
+    return (0, path_1.resolve)(process.cwd(), 'models');
+}

package/dist/NoveltyScorer.d.ts

@@ -0,0 +1,40 @@
+/**
+ * NoveltyScorer — 代码层新颖度评估
+ *
+ * 在 LLM 自评 novelty 之外，通过文本相似度对输入假设进行再评估：
+ * 1. 与近期假设（past 30）的 idea 文本对比，Jaccard 相似度 > 0.5 → 扣 15 分
+ * 2. 与已拒绝假设的 idea 文本对比，Jaccard 相似度 > 0.6 → 标记为 rejected
+ */
+/** Jaccard 相似度：|A ∩ B| / |A ∪ B| */
+export declare function jaccardSimilarity(a: string, b: string): number;
+export interface NoveltyVerdict {
+    /** 调整后的新颖度（0-100），可能被扣分 */
+    adjustedNovelty: number;
+    /** 是否应被自动拒绝（与已拒绝假设高度相似） */
+    shouldReject: boolean;
+    /** 为什么拒绝 */
+    rejectReason?: string;
+    /** 与最相似假设的信息 */
+    mostSimilarTitle?: string;
+    mostSimilarScore: number;
+}
+/**
+ * 对一条新假设进行代码层新颖度评估
+ *
+ * @param candidate 新假设
+ * @param recentHypotheses 近期假设（用于扣分）
+ * @param rejectedHypotheses 已拒绝假设（用于自动拒绝）
+ * @returns NoveltyVerdict
+ */
+export declare function evaluateNovelty(candidate: {
+    title: string;
+    idea: string;
+    novelty: number;
+}, recentHypotheses: {
+    title: string;
+    idea: string;
+    novelty: number;
+}[], rejectedHypotheses: {
+    title: string;
+    idea: string;
+}[]): NoveltyVerdict;