@akemi-mio/creativity 0.1.0 → 0.1.1

package/dist/WhenThenRunner.js

@@ -0,0 +1,358 @@
+"use strict";
+/**
+ * WhenThenRunner — 声明式 WHEN/THEN 受限 DSL 运行器（机制涌现 P2a，定案 D5/R5/A2）
+ *
+ * 候选执行不写任意代码：DSL 查表求值（阈值比较 + 字段存在性 + 枚举匹配，禁 JS eval）。
+ * 步骤依赖执行 + 显式 named outputs（无隐式上下文注入）。
+ * resourceBudget 编译为 CapabilityToken.constraints。
+ * 求值器输入输出全白名单序列化（JSON number/boolean/string）。
+ * 条件字符串长度上限，解析失败 = fail-closed（步骤跳过 + 记 guardrail 事件，不中断实验、不泄漏沙箱内部）。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CONDITION_LIST_LEN = exports.MAX_CONDITION_STRING_VALUE_LEN = exports.MAX_CONDITION_FIELD_LEN = void 0;
+exports.lookupField = lookupField;
+exports.evaluateCondition = evaluateCondition;
+exports.evaluateWhen = evaluateWhen;
+exports.compileBudgetToConstraints = compileBudgetToConstraints;
+exports.topologicalOrder = topologicalOrder;
+exports.runWhenThenRule = runWhenThenRule;
+// ══════════════════════════════════════════
+// 求值器（白名单查表，禁 eval）
+// ══════════════════════════════════════════
+/** 条件字符串长度上限（防超长注入） */
+exports.MAX_CONDITION_FIELD_LEN = 128;
+exports.MAX_CONDITION_STRING_VALUE_LEN = 512;
+exports.MAX_CONDITION_LIST_LEN = 32;
+function isScalar(v) {
+    return typeof v === 'number' || typeof v === 'boolean' || typeof v === 'string';
+}
+/** 按点分路径从 context 取值；中间路径不存在返回 undefined。不深入数组索引（防原型链）。 */
+function lookupField(context, field) {
+    if (typeof field !== 'string' || field.length === 0 || field.length > exports.MAX_CONDITION_FIELD_LEN)
+        return undefined;
+    // 禁原型链：字段不得含 `__proto__` / `constructor` / `prototype`
+    if (field.includes('__proto__') || field.includes('constructor') || field.includes('prototype'))
+        return undefined;
+    const parts = field.split('.');
+    let cur = context;
+    for (const p of parts) {
+        if (cur === null || typeof cur !== 'object' || Array.isArray(cur))
+            return undefined;
+        const obj = cur;
+        if (!Object.prototype.hasOwnProperty.call(obj, p))
+            return undefined;
+        cur = obj[p];
+    }
+    return cur;
+}
+/** 求值单个 WHEN 条件；解析失败（非法字段/值/操作符）返回 null（调用方 fail-closed）。 */
+function evaluateCondition(context, cond) {
+    if (!cond || typeof cond !== 'object')
+        return null;
+    const { field, op, value } = cond;
+    if (typeof field !== 'string' || field.length === 0 || field.length > exports.MAX_CONDITION_FIELD_LEN)
+        return null;
+    if (field.includes('__proto__') || field.includes('constructor') || field.includes('prototype'))
+        return null;
+    const actual = lookupField(context, field);
+    switch (op) {
+        case 'exists':
+            return actual !== undefined && actual !== null;
+        case 'notExists':
+            return actual === undefined || actual === null;
+        case 'eq':
+        case 'neq':
+        case 'gt':
+        case 'gte':
+        case 'lt':
+        case 'lte': {
+            if (!isScalar(value))
+                return null;
+            if (!isScalar(actual))
+                return false;
+            switch (op) {
+                case 'eq':
+                    return actual === value;
+                case 'neq':
+                    return actual !== value;
+                case 'gt':
+                    return typeof actual === 'number' && typeof value === 'number' && actual > value;
+                case 'gte':
+                    return typeof actual === 'number' && typeof value === 'number' && actual >= value;
+                case 'lt':
+                    return typeof actual === 'number' && typeof value === 'number' && actual < value;
+                case 'lte':
+                    return typeof actual === 'number' && typeof value === 'number' && actual <= value;
+                default:
+                    return null;
+            }
+        }
+        case 'in':
+        case 'nin': {
+            if (!Array.isArray(value) || value.length > exports.MAX_CONDITION_LIST_LEN)
+                return null;
+            if (!value.every((v) => typeof v === 'string' && v.length <= exports.MAX_CONDITION_STRING_VALUE_LEN))
+                return null;
+            if (!isScalar(actual))
+                return false;
+            const hit = value.includes(actual);
+            return op === 'in' ? hit : !hit;
+        }
+        default:
+            // 未知操作符 = 解析失败
+            return null;
+    }
+}
+/** 求值全部 WHEN 条件（AND）；任一解析失败返回 null（fail-closed）。 */
+function evaluateWhen(context, when) {
+    if (!when || when.length === 0)
+        return true;
+    for (const c of when) {
+        const r = evaluateCondition(context, c);
+        if (r === null)
+            return null;
+        if (r === false)
+            return false;
+    }
+    return true;
+}
+// ══════════════════════════════════════════
+// resourceBudget → CapabilityToken.constraints
+// ══════════════════════════════════════════
+/** 把 ResourceBudgetSpec 编译为 CapabilityToken.constraints（白名单字段）。 */
+function compileBudgetToConstraints(budget, ruleBudget) {
+    // 步骤级覆盖规则级
+    const b = budget ?? ruleBudget;
+    if (!b)
+        return undefined;
+    const constraints = {};
+    if (typeof b.maxCalls === 'number' && Number.isFinite(b.maxCalls) && b.maxCalls >= 0) {
+        constraints.maxCalls = Math.floor(b.maxCalls);
+    }
+    if (typeof b.maxTokens === 'number' && Number.isFinite(b.maxTokens) && b.maxTokens >= 0) {
+        constraints.maxTokens = Math.floor(b.maxTokens);
+    }
+    if (typeof b.expiryMs === 'number' && Number.isFinite(b.expiryMs) && b.expiryMs >= 0) {
+        constraints.expiryMs = Math.floor(b.expiryMs);
+    }
+    if (b.allowedValues && typeof b.allowedValues === 'object' && !Array.isArray(b.allowedValues)) {
+        const allowed = {};
+        for (const [k, arr] of Object.entries(b.allowedValues)) {
+            if (Array.isArray(arr) && arr.every((v) => typeof v === 'string' && v.length <= exports.MAX_CONDITION_STRING_VALUE_LEN)) {
+                if (arr.length <= exports.MAX_CONDITION_LIST_LEN)
+                    allowed[k] = arr;
+            }
+        }
+        if (Object.keys(allowed).length > 0)
+            constraints.allowedValues = allowed;
+    }
+    return Object.keys(constraints).length > 0 ? constraints : undefined;
+}
+// ══════════════════════════════════════════
+// 依赖调度（DAG 拓扑 + named outputs）
+// ══════════════════════════════════════════
+/** 拓扑排序步骤；环路/未知依赖返回 null（fail-closed）。 */
+function topologicalOrder(steps) {
+    const byId = new Map();
+    for (const s of steps) {
+        if (!s || typeof s.id !== 'string' || s.id.length === 0)
+            return null;
+        if (byId.has(s.id))
+            return null;
+        byId.set(s.id, s);
+    }
+    const indegree = new Map();
+    const children = new Map();
+    for (const s of steps) {
+        indegree.set(s.id, 0);
+    }
+    for (const s of steps) {
+        const deps = s.dependsOn ?? [];
+        for (const d of deps) {
+            if (!byId.has(d))
+                return null; // 未知依赖
+            indegree.set(s.id, (indegree.get(s.id) ?? 0) + 1);
+            const list = children.get(d) ?? [];
+            list.push(s.id);
+            children.set(d, list);
+        }
+    }
+    const queue = [];
+    for (const [id, deg] of indegree) {
+        if (deg === 0)
+            queue.push(id);
+    }
+    queue.sort();
+    const order = [];
+    while (queue.length > 0) {
+        const id = queue.shift();
+        order.push(byId.get(id));
+        for (const child of children.get(id) ?? []) {
+            const nd = (indegree.get(child) ?? 1) - 1;
+            indegree.set(child, nd);
+            if (nd === 0)
+                queue.push(child);
+        }
+        queue.sort();
+    }
+    if (order.length !== steps.length)
+        return null; // 环
+    return order;
+}
+/**
+ * 执行一条 WHEN/THEN 规则。
+ *
+ * - 按 DAG 拓扑顺序调度
+ * - 每步先求值 WHEN（解析失败 → fail-closed skip + guardrail 事件）
+ * - 输入从初始 context + 上游 named outputs 显式解析（无隐式注入）
+ * - 预算编译为 CapabilityToken.constraints 传给 executor
+ * - 任一步失败不中断实验：后续依赖步骤 blocked，独立步骤继续
+ */
+async function runWhenThenRule(rule, context, executeStep, options) {
+    const events = [];
+    const namedOutputs = { ...(options?.initialOutputs ?? {}) };
+    const stepStatus = new Map();
+    const stepReason = new Map();
+    const stepOutputs = new Map();
+    const sink = (ev) => {
+        events.push(ev);
+        options?.onEvent?.(ev);
+    };
+    // 1. 拓扑排序（环/未知依赖 → 整规则 fail-closed）
+    const order = topologicalOrder(rule.steps ?? []);
+    if (!order) {
+        sink({
+            event_type: 'whenthen.rule.failed',
+            rule_id: rule.id,
+            reason: 'invalid_graph',
+            outcome: 'failed',
+            timestamp: Date.now(),
+        });
+        return { success: false, namedOutputs, steps: [], events };
+    }
+    // 2. 逐步骤
+    for (const step of order) {
+        const deps = step.dependsOn ?? [];
+        const depBlocked = deps.some((d) => {
+            const st = stepStatus.get(d);
+            return st === 'failed' || st === 'blocked' || st === 'skipped';
+        });
+        if (depBlocked) {
+            stepStatus.set(step.id, 'blocked');
+            stepReason.set(step.id, 'upstream_blocked');
+            sink({
+                event_type: 'whenthen.step.skipped',
+                rule_id: rule.id,
+                step_id: step.id,
+                reason: 'upstream_blocked',
+                outcome: 'skipped',
+                timestamp: Date.now(),
+            });
+            continue;
+        }
+        // 3. WHEN 求值（fail-closed）
+        const whenOk = evaluateWhen(context, step.when);
+        if (whenOk === null) {
+            stepStatus.set(step.id, 'skipped');
+            stepReason.set(step.id, 'when_parse_failed');
+            sink({
+                event_type: 'whenthen.step.skipped',
+                rule_id: rule.id,
+                step_id: step.id,
+                reason: 'when_parse_failed',
+                outcome: 'skipped',
+                timestamp: Date.now(),
+            });
+            continue;
+        }
+        if (whenOk === false) {
+            stepStatus.set(step.id, 'skipped');
+            stepReason.set(step.id, 'when_not_satisfied');
+            sink({
+                event_type: 'whenthen.step.skipped',
+                rule_id: rule.id,
+                step_id: step.id,
+                reason: 'when_not_satisfied',
+                outcome: 'skipped',
+                timestamp: Date.now(),
+            });
+            continue;
+        }
+        // 4. 显式 named inputs 解析（路径 = 初始 context 或 namedOutputs）
+        const inputs = {};
+        if (step.inputs) {
+            for (const [name, path] of Object.entries(step.inputs)) {
+                if (typeof path !== 'string' || path.length === 0 || path.length > exports.MAX_CONDITION_FIELD_LEN)
+                    continue;
+                if (path.includes('__proto__') || path.includes('constructor') || path.includes('prototype'))
+                    continue;
+                const v = lookupField(namedOutputs, path) ?? lookupField(context, path);
+                if (v !== undefined)
+                    inputs[name] = v;
+            }
+        }
+        // 5. 预算编译
+        const constraints = compileBudgetToConstraints(step.resourceBudget, rule.resourceBudget);
+        // 6. 执行
+        try {
+            const result = await executeStep({
+                stepId: step.id,
+                capabilityId: step.capabilityId,
+                inputs,
+                constraints,
+            });
+            if (result.success) {
+                stepStatus.set(step.id, 'ok');
+                const outs = result.outputs ?? {};
+                stepOutputs.set(step.id, outs);
+                for (const [k, v] of Object.entries(outs)) {
+                    namedOutputs[k] = v;
+                    namedOutputs[`${step.id}.${k}`] = v;
+                }
+            }
+            else {
+                stepStatus.set(step.id, 'failed');
+                stepReason.set(step.id, result.error ?? 'step_failed');
+                sink({
+                    event_type: 'whenthen.step.failed',
+                    rule_id: rule.id,
+                    step_id: step.id,
+                    reason: result.error ?? 'step_failed',
+                    outcome: 'failed',
+                    timestamp: Date.now(),
+                });
+            }
+        }
+        catch {
+            stepStatus.set(step.id, 'failed');
+            stepReason.set(step.id, 'step_exception');
+            sink({
+                event_type: 'whenthen.step.failed',
+                rule_id: rule.id,
+                step_id: step.id,
+                reason: 'step_exception',
+                outcome: 'failed',
+                timestamp: Date.now(),
+            });
+        }
+    }
+    const allOk = order.every((s) => stepStatus.get(s.id) === 'ok' || stepStatus.get(s.id) === 'skipped');
+    sink({
+        event_type: allOk ? 'whenthen.rule.complete' : 'whenthen.rule.failed',
+        rule_id: rule.id,
+        reason: allOk ? 'complete' : 'partial_failure',
+        outcome: allOk ? 'success' : 'partial',
+        timestamp: Date.now(),
+    });
+    return {
+        success: allOk,
+        namedOutputs,
+        steps: order.map((s) => ({
+            id: s.id,
+            status: stepStatus.get(s.id) ?? 'blocked',
+            reason: stepReason.get(s.id),
+            outputs: stepOutputs.get(s.id),
+        })),
+        events,
+    };
+}

package/dist/types.d.ts

@@ -85,7 +85,7 @@ export interface Hypothesis {
     impact: number;
     /** 逻辑一致性评分 0-100（第四维，评审/生成时打分，可缺省视为 50） */
     logic?: number;
-    status: 'draft' | 'active' | 'experimenting' | 'validated' | 'rejected';
+    status: 'draft' | 'active' | 'testing' | 'validated' | 'rejected';
     createdAt: number;
     /** The rotation technique this hypothesis was generated with (idea.generate provenance.technique). */
     technique?: string;
@@ -112,6 +112,20 @@ export interface Hypothesis {
     implementedCommitSha?: string;
     implementedAt?: number;
     implementationNote?: string;
+    /** 机制假设：提出的关系边（带 proposedRelations 即机制假设，否则普通创意） */
+    proposedRelations?: ProposedRelation[];
+    /** 证伪条件：命中任一条件则机制假设可被拒绝 */
+    falsificationConditions?: string[];
+    /** 触发本假设的 observation/trace id 溯源 */
+    sourceObservationIds?: string[];
+}
+/** 机制图的一条候选边：A --[effect]--> B */
+export interface ProposedRelation {
+    from: string;
+    to: string;
+    effect: string;
+    /** 推断来源：identity=verified | inferred（A6 confidence 映射） */
+    inference?: 'identity' | 'inferred';
 }
 export interface ExperimentPlan {
     hypothesisId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akemi-mio/creativity",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Creativity layer: ideas, writing, blog, image, inspiration",
   "main": "./dist/IdeaGenerator.js",
   "types": "./dist/IdeaGenerator.d.ts",
@@ -25,14 +25,43 @@
       "require": "./dist/types.js",
       "default": "./dist/types.js"
     },
+    "./MechanismRegistry": {
+      "types": "./dist/MechanismRegistry.d.ts",
+      "require": "./dist/MechanismRegistry.js",
+      "default": "./dist/MechanismRegistry.js"
+    },
+    "./ExperimentRunStore": {
+      "types": "./dist/ExperimentRunStore.d.ts",
+      "require": "./dist/ExperimentRunStore.js",
+      "default": "./dist/ExperimentRunStore.js"
+    },
+    "./WhenThenRunner": {
+      "types": "./dist/WhenThenRunner.d.ts",
+      "require": "./dist/WhenThenRunner.js",
+      "default": "./dist/WhenThenRunner.js"
+    },
+    "./MechanismGraph": {
+      "types": "./dist/MechanismGraph.d.ts",
+      "require": "./dist/MechanismGraph.js",
+      "default": "./dist/MechanismGraph.js"
+    },
+    "./InsightSamplingExperiment": {
+      "types": "./dist/InsightSamplingExperiment.d.ts",
+      "require": "./dist/InsightSamplingExperiment.js",
+      "default": "./dist/InsightSamplingExperiment.js"
+    },
     "./package.json": "./package.json"
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "prepublishOnly": "npm run build"
   },
-  "engines": { "node": ">=18" },
+  "engines": {
+    "node": ">=18"
+  },
   "license": "MIT",
   "dependencies": {
     "@akemi-mio/core": "^0.1.0"