oh-my-knowledge 0.48.0 → 0.49.0

package/dist/inputs/load-samples.js

@@ -1,6 +1,8 @@
 import { readFileSync, readdirSync, statSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import yaml from 'js-yaml';
+import { dependencyRequirementsValidationError, sampleContractValidationError, } from '../shared/sample-contract.js';
+import { setOwnRecordValue } from '../shared/record-count.js';
 export function parseYaml(text) {
     try {
         return yaml.load(text);
@@ -70,7 +72,7 @@ function loadSamplesFromDir(dir) {
                     `defined in both "${prev}" and "${f}"`);
             }
             seenIds.set(s.sample_id, f);
-            sampleSourceById[s.sample_id] = path;
+            setOwnRecordValue(sampleSourceById, s.sample_id, path);
         }
         allSamples.push(...single.samples);
         mergedRequires = mergeRequires(mergedRequires, single.requires);
@@ -118,10 +120,20 @@ export function validateSamples(samples) {
         'workflow',
         'workflow_node',
     ]);
+    const firstIndexBySampleId = new Map();
     for (const [i, sample] of samples.entries()) {
+        if (!sample || typeof sample !== 'object' || Array.isArray(sample)) {
+            throw new Error(`samples[${i}] invalid sample contract: sample must be an object`);
+        }
         if (!sample.sample_id || typeof sample.sample_id !== 'string') {
             throw new Error(`samples[${i}] missing or invalid required field: sample_id (must be a non-empty string)`);
         }
+        const firstIndex = firstIndexBySampleId.get(sample.sample_id);
+        if (firstIndex !== undefined) {
+            throw new Error(`duplicate sample_id "${sample.sample_id}" at samples[${i}] `
+                + `(first defined at samples[${firstIndex}])`);
+        }
+        firstIndexBySampleId.set(sample.sample_id, i);
         if (!sample.prompt || typeof sample.prompt !== 'string') {
             throw new Error(`samples[${i}] (${sample.sample_id}) missing or invalid required field: prompt (must be a non-empty string)`);
         }
@@ -247,6 +259,10 @@ export function validateSamples(samples) {
                 emitViolation(`${label}: regex pattern 含 CJK 字符 — 同样的语义匹配应走 rubric → judge,而不是字面正则: ${JSON.stringify(a.pattern)}`);
             }
         }
+        const contractError = sampleContractValidationError(sample);
+        if (contractError) {
+            throw new Error(`samples[${i}] (${sample.sample_id}) invalid sample contract: ${contractError}`);
+        }
     }
 }
 function loadSampleFile(samplesPath) {
@@ -264,6 +280,12 @@ function loadSampleFile(samplesPath) {
         const wrapper = parsed;
         samples = wrapper.samples;
         requires = wrapper.requires;
+        if (requires !== undefined) {
+            const requiresError = dependencyRequirementsValidationError(requires);
+            if (requiresError) {
+                throw new Error(`invalid samples file: ${samplesPath}: ${requiresError}`);
+            }
+        }
     }
     else {
         throw new Error(`invalid samples file shape: ${samplesPath} (expected an array or an object with a 'samples' field)`);

package/dist/inputs/mcp-resolver.js

@@ -35,6 +35,7 @@ import { resolve } from 'node:path';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { isPlaceholderUrl } from './url-fetcher.js';
+import { ownRecordValue, setOwnRecordValue } from '../shared/record-count.js';
 // Reuse the same URL regex from url-fetcher.mjs
 const URL_REGEX = /https?:\/\/[A-Za-z0-9\-._~:/?#[\]@!$&'()*+,;=%]+/g;
 const MCP_CALL_TIMEOUT_MS = 30_000;
@@ -83,7 +84,7 @@ export function loadMcpConfig(configPath) {
     const eligible = {};
     for (const [name, def] of Object.entries(serverDefs)) {
         if (isMcpServerDef(def) && def.urlPatterns.length > 0) {
-            eligible[name] = def;
+            setOwnRecordValue(eligible, name, def);
         }
     }
     if (Object.keys(eligible).length === 0)
@@ -145,7 +146,9 @@ export async function resolveMcpUrls(samples, mcpServers) {
     const fetched = new Map(); // url -> { ok, content, error }
     const fetchPromises = [];
     for (const [serverName, urls] of serverUrlGroups) {
-        fetchPromises.push(fetchFromServer(serverName, mcpServers[serverName], urls, fetched));
+        const server = ownRecordValue(mcpServers, serverName);
+        if (server)
+            fetchPromises.push(fetchFromServer(serverName, server, urls, fetched));
     }
     await Promise.allSettled(fetchPromises);
     // 4. Report failures
@@ -208,7 +211,7 @@ function buildToolArgs(fetchTool, url) {
             return null;
         const args = {};
         for (const [key, template] of Object.entries(params)) {
-            args[key] = template.replace(/\$(\d+)/g, (_, i) => match[Number(i)] || '');
+            setOwnRecordValue(args, key, template.replace(/\$(\d+)/g, (_, i) => match[Number(i)] || ''));
         }
         return args;
     }

package/dist/inputs/sample-document.d.ts

@@ -0,0 +1,11 @@
+import type { Sample } from '../types/index.js';
+import { type LoadSamplesResult } from './load-samples.js';
+export declare function parseSampleDocument(filePath: string): unknown;
+export declare function getSamplesArray(document: unknown, filePath: string): Sample[];
+export declare function stringifySampleDocument(filePath: string, document: unknown): string;
+/**
+ * Persist only changed samples back to the source file that originally owned each
+ * sample_id. JSON/YAML and array/wrapper shapes are retained, including `requires`
+ * and any other wrapper metadata.
+ */
+export declare function writeFixedSamplesToSources(loaded: Pick<LoadSamplesResult, 'sourceFiles' | 'sampleSourceById'>, samples: Sample[], changedIds: ReadonlySet<string>): string[];

package/dist/inputs/sample-document.js

@@ -0,0 +1,96 @@
+import { lstatSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { dirname, join } from 'node:path';
+import yaml from 'js-yaml';
+import { withFileLock } from '../shared/file-lock.js';
+import { ownRecordValue } from '../shared/record-count.js';
+import { parseYaml, validateSamples } from './load-samples.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isYamlPath(filePath) {
+    return /\.(ya?ml)$/i.test(filePath);
+}
+export function parseSampleDocument(filePath) {
+    const raw = readFileSync(filePath, 'utf-8');
+    return isYamlPath(filePath) ? parseYaml(raw) : JSON.parse(raw);
+}
+export function getSamplesArray(document, filePath) {
+    if (Array.isArray(document))
+        return document;
+    if (isRecord(document) && Array.isArray(document.samples)) {
+        return document.samples;
+    }
+    throw new Error(`invalid samples file shape: ${filePath} `
+        + `(expected an array or an object with a 'samples' field)`);
+}
+export function stringifySampleDocument(filePath, document) {
+    if (isYamlPath(filePath)) {
+        return yaml.dump(document, { lineWidth: -1, noRefs: true });
+    }
+    return JSON.stringify(document, null, 2);
+}
+function writableFilePath(filePath) {
+    return lstatSync(filePath).isSymbolicLink() ? realpathSync(filePath) : filePath;
+}
+function atomicWriteFile(filePath, content) {
+    const targetPath = writableFilePath(filePath);
+    const tempPath = join(dirname(targetPath), `.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`);
+    try {
+        writeFileSync(tempPath, content, { mode: statSync(targetPath).mode & 0o777 });
+        renameSync(tempPath, targetPath);
+    }
+    catch (error) {
+        try {
+            unlinkSync(tempPath);
+        }
+        catch {
+            // The rename may already have consumed the temporary file.
+        }
+        throw error;
+    }
+}
+/**
+ * Persist only changed samples back to the source file that originally owned each
+ * sample_id. JSON/YAML and array/wrapper shapes are retained, including `requires`
+ * and any other wrapper metadata.
+ */
+export function writeFixedSamplesToSources(loaded, samples, changedIds) {
+    if (changedIds.size === 0)
+        return [];
+    const fixedById = new Map(samples.map((sample) => [sample.sample_id, sample]));
+    const idsByFile = new Map();
+    for (const sampleId of changedIds) {
+        const filePath = ownRecordValue(loaded.sampleSourceById, sampleId);
+        if (!filePath)
+            throw new Error(`sample ${sampleId} source file not found`);
+        if (!loaded.sourceFiles.includes(filePath)) {
+            throw new Error(`sample ${sampleId} source file is outside the loaded sample set`);
+        }
+        if (!fixedById.has(sampleId)) {
+            throw new Error(`fixed sample ${sampleId} is missing from the update set`);
+        }
+        const ids = idsByFile.get(filePath) ?? new Set();
+        ids.add(sampleId);
+        idsByFile.set(filePath, ids);
+    }
+    for (const [filePath, ids] of idsByFile.entries()) {
+        const targetPath = writableFilePath(filePath);
+        withFileLock(`${targetPath}.omk.lock`, () => {
+            const document = parseSampleDocument(filePath);
+            const fileSamples = getSamplesArray(document, filePath);
+            const existingIds = new Set(fileSamples.map((sample) => sample.sample_id));
+            for (const sampleId of ids) {
+                if (!existingIds.has(sampleId)) {
+                    throw new Error(`sample ${sampleId} is no longer present in ${filePath}`);
+                }
+            }
+            const nextSamples = fileSamples.map((sample) => (ids.has(sample.sample_id) ? fixedById.get(sample.sample_id) : sample));
+            validateSamples(nextSamples);
+            const nextDocument = Array.isArray(document)
+                ? nextSamples
+                : { ...document, samples: nextSamples };
+            atomicWriteFile(filePath, stringifySampleDocument(filePath, nextDocument));
+        });
+    }
+    return [...idsByFile.keys()];
+}

package/dist/managed/evidence.d.ts

@@ -8,6 +8,7 @@ export declare function buildEvidenceRef(report: EvaluationReport, variant: stri
 export interface RecordedEvidence {
     recordId: string;
     name: string;
+    variant: string;
     contentHash: string;
     /** true ⇒ evidence.contentHash 等于记录当前 contentHash → deriveManagedState 计为当前证据 →
      *  measurable。false ⇒ 测的是旧内容(已 drift),证据留存但不绑当前版本。 */

package/dist/managed/evidence.js

@@ -149,7 +149,7 @@ export function recordEvalEvidence(report, verdict, recordedAt, opts = {}) {
         const merged = appendManagedEvidence(dir, rec.id, ref);
         if (!merged)
             continue;
-        out.push({ recordId: rec.id, name: rec.name, contentHash: ref.contentHash, bound: ref.contentHash === merged.contentHash });
+        out.push({ recordId: rec.id, name: rec.name, variant: variantKey, contentHash: ref.contentHash, bound: ref.contentHash === merged.contentHash });
     }
     return out;
 }