@contractspec/example.versioned-knowledge-base 3.7.6 → 3.7.10

package/src/events.ts

@@ -1,102 +1,102 @@
 import { defineEvent } from '@contractspec/lib.contracts-spec';
-import { ScalarTypeEnum, defineSchemaModel } from '@contractspec/lib.schema';
+import { defineSchemaModel, ScalarTypeEnum } from '@contractspec/lib.schema';
 
 const KbSourceIngestedPayload = defineSchemaModel({
-  name: 'KbSourceIngestedPayload',
-  description: 'Emitted when a source document is ingested.',
-  fields: {
-    sourceDocumentId: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false,
-    },
-    jurisdiction: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    hash: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-  },
+	name: 'KbSourceIngestedPayload',
+	description: 'Emitted when a source document is ingested.',
+	fields: {
+		sourceDocumentId: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false,
+		},
+		jurisdiction: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+		hash: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+	},
 });
 
 export const KbSourceIngestedEvent = defineEvent({
-  meta: {
-    key: 'kb.source.ingested',
-    version: '1.0.0',
-    description: 'Source document ingested (immutable).',
-    stability: 'experimental',
-    owners: ['@examples'],
-    tags: ['knowledge'],
-  },
-  payload: KbSourceIngestedPayload,
+	meta: {
+		key: 'kb.source.ingested',
+		version: '1.0.0',
+		description: 'Source document ingested (immutable).',
+		stability: 'experimental',
+		owners: ['@examples'],
+		tags: ['knowledge'],
+	},
+	payload: KbSourceIngestedPayload,
 });
 
 const KbRuleVersionCreatedPayload = defineSchemaModel({
-  name: 'KbRuleVersionCreatedPayload',
-  description: 'Emitted when a rule version draft is created.',
-  fields: {
-    ruleVersionId: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false,
-    },
-    ruleId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    jurisdiction: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    status: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-  },
+	name: 'KbRuleVersionCreatedPayload',
+	description: 'Emitted when a rule version draft is created.',
+	fields: {
+		ruleVersionId: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false,
+		},
+		ruleId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+		jurisdiction: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+		status: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+	},
 });
 
 export const KbRuleVersionCreatedEvent = defineEvent({
-  meta: {
-    key: 'kb.ruleVersion.created',
-    version: '1.0.0',
-    description: 'Rule version created (draft).',
-    stability: 'experimental',
-    owners: ['@examples'],
-    tags: ['knowledge'],
-  },
-  payload: KbRuleVersionCreatedPayload,
+	meta: {
+		key: 'kb.ruleVersion.created',
+		version: '1.0.0',
+		description: 'Rule version created (draft).',
+		stability: 'experimental',
+		owners: ['@examples'],
+		tags: ['knowledge'],
+	},
+	payload: KbRuleVersionCreatedPayload,
 });
 
 const KbRuleVersionApprovedPayload = defineSchemaModel({
-  name: 'KbRuleVersionApprovedPayload',
-  description: 'Emitted when a rule version is approved.',
-  fields: {
-    ruleVersionId: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false,
-    },
-    approver: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-  },
+	name: 'KbRuleVersionApprovedPayload',
+	description: 'Emitted when a rule version is approved.',
+	fields: {
+		ruleVersionId: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false,
+		},
+		approver: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+	},
 });
 
 export const KbRuleVersionApprovedEvent = defineEvent({
-  meta: {
-    key: 'kb.ruleVersion.approved',
-    version: '1.0.0',
-    description: 'Rule version approved (human verified).',
-    stability: 'experimental',
-    owners: ['@examples'],
-    tags: ['knowledge'],
-  },
-  payload: KbRuleVersionApprovedPayload,
+	meta: {
+		key: 'kb.ruleVersion.approved',
+		version: '1.0.0',
+		description: 'Rule version approved (human verified).',
+		stability: 'experimental',
+		owners: ['@examples'],
+		tags: ['knowledge'],
+	},
+	payload: KbRuleVersionApprovedPayload,
 });
 
 const KbSnapshotPublishedPayload = defineSchemaModel({
-  name: 'KbSnapshotPublishedPayload',
-  description: 'Emitted when a KB snapshot is published.',
-  fields: {
-    snapshotId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    jurisdiction: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    includedRuleVersionsCount: {
-      type: ScalarTypeEnum.Int_unsecure(),
-      isOptional: false,
-    },
-  },
+	name: 'KbSnapshotPublishedPayload',
+	description: 'Emitted when a KB snapshot is published.',
+	fields: {
+		snapshotId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+		jurisdiction: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+		includedRuleVersionsCount: {
+			type: ScalarTypeEnum.Int_unsecure(),
+			isOptional: false,
+		},
+	},
 });
 
 export const KbSnapshotPublishedEvent = defineEvent({
-  meta: {
-    key: 'kb.snapshot.published',
-    version: '1.0.0',
-    description: 'KB snapshot published.',
-    stability: 'experimental',
-    owners: ['@examples'],
-    tags: ['knowledge'],
-  },
-  payload: KbSnapshotPublishedPayload,
+	meta: {
+		key: 'kb.snapshot.published',
+		version: '1.0.0',
+		description: 'KB snapshot published.',
+		stability: 'experimental',
+		owners: ['@examples'],
+		tags: ['knowledge'],
+	},
+	payload: KbSnapshotPublishedPayload,
 });

package/src/example.ts

@@ -1,34 +1,34 @@
 import { defineExample } from '@contractspec/lib.contracts-spec';
 
 const example = defineExample({
-  meta: {
-    key: 'versioned-knowledge-base',
-    version: '1.0.0',
-    title: 'Versioned Knowledge Base',
-    description:
-      'Curated KB with immutable sources, reviewable rule versions, and published snapshots.',
-    kind: 'knowledge',
-    visibility: 'public',
-    stability: 'experimental',
-    owners: ['@platform.core'],
-    tags: ['knowledge', 'versioning', 'snapshots'],
-  },
-  docs: {
-    rootDocId: 'docs.examples.versioned-knowledge-base',
-  },
-  entrypoints: {
-    packageName: '@contractspec/example.versioned-knowledge-base',
-    feature: './feature',
-    contracts: './contracts',
-    handlers: './handlers',
-    docs: './docs',
-  },
-  surfaces: {
-    templates: true,
-    sandbox: { enabled: true, modes: ['markdown', 'specs', 'builder'] },
-    studio: { enabled: true, installable: true },
-    mcp: { enabled: true },
-  },
+	meta: {
+		key: 'versioned-knowledge-base',
+		version: '1.0.0',
+		title: 'Versioned Knowledge Base',
+		description:
+			'Curated KB with immutable sources, reviewable rule versions, and published snapshots.',
+		kind: 'knowledge',
+		visibility: 'public',
+		stability: 'experimental',
+		owners: ['@platform.core'],
+		tags: ['knowledge', 'versioning', 'snapshots'],
+	},
+	docs: {
+		rootDocId: 'docs.examples.versioned-knowledge-base',
+	},
+	entrypoints: {
+		packageName: '@contractspec/example.versioned-knowledge-base',
+		feature: './feature',
+		contracts: './contracts',
+		handlers: './handlers',
+		docs: './docs',
+	},
+	surfaces: {
+		templates: true,
+		sandbox: { enabled: true, modes: ['markdown', 'specs', 'builder'] },
+		studio: { enabled: true, installable: true },
+		mcp: { enabled: true },
+	},
 });
 
 export default example;

package/src/handlers/memory.handlers.test.ts

@@ -3,79 +3,79 @@ import { describe, expect, it } from 'bun:test';
 import { createMemoryKbHandlers, createMemoryKbStore } from './memory.handlers';
 
 describe('@contractspec/example.versioned-knowledge-base memory handlers', () => {
-  it('requires sourceRefs for rule versions (traceability)', async () => {
-    const store = createMemoryKbStore();
-    const kb = createMemoryKbHandlers(store);
-    await kb.createRule({ id: 'rule_1', jurisdiction: 'EU', topicKey: 't1' });
-    await expect(
-      kb.upsertRuleVersion({ ruleId: 'rule_1', content: 'x', sourceRefs: [] })
-    ).rejects.toThrow('SOURCE_REFS_REQUIRED');
-  });
+	it('requires sourceRefs for rule versions (traceability)', async () => {
+		const store = createMemoryKbStore();
+		const kb = createMemoryKbHandlers(store);
+		await kb.createRule({ id: 'rule_1', jurisdiction: 'EU', topicKey: 't1' });
+		await expect(
+			kb.upsertRuleVersion({ ruleId: 'rule_1', content: 'x', sourceRefs: [] })
+		).rejects.toThrow('SOURCE_REFS_REQUIRED');
+	});
 
-  it('snapshot includes only approved rule versions for that jurisdiction', async () => {
-    const store = createMemoryKbStore();
-    const kb = createMemoryKbHandlers(store);
+	it('snapshot includes only approved rule versions for that jurisdiction', async () => {
+		const store = createMemoryKbStore();
+		const kb = createMemoryKbHandlers(store);
 
-    await kb.createRule({ id: 'rule_eu', jurisdiction: 'EU', topicKey: 'tax' });
-    await kb.createRule({ id: 'rule_fr', jurisdiction: 'FR', topicKey: 'tax' });
+		await kb.createRule({ id: 'rule_eu', jurisdiction: 'EU', topicKey: 'tax' });
+		await kb.createRule({ id: 'rule_fr', jurisdiction: 'FR', topicKey: 'tax' });
 
-    const euDraft = await kb.upsertRuleVersion({
-      ruleId: 'rule_eu',
-      content: 'EU rule content',
-      sourceRefs: [{ sourceDocumentId: 'src1' }],
-    });
-    const frDraft = await kb.upsertRuleVersion({
-      ruleId: 'rule_fr',
-      content: 'FR rule content',
-      sourceRefs: [{ sourceDocumentId: 'src2' }],
-    });
+		const euDraft = await kb.upsertRuleVersion({
+			ruleId: 'rule_eu',
+			content: 'EU rule content',
+			sourceRefs: [{ sourceDocumentId: 'src1' }],
+		});
+		const frDraft = await kb.upsertRuleVersion({
+			ruleId: 'rule_fr',
+			content: 'FR rule content',
+			sourceRefs: [{ sourceDocumentId: 'src2' }],
+		});
 
-    const euApproved = await kb.approveRuleVersion({
-      ruleVersionId: euDraft.id,
-      approver: 'expert_1',
-    });
-    await kb.approveRuleVersion({
-      ruleVersionId: frDraft.id,
-      approver: 'expert_1',
-    });
+		const euApproved = await kb.approveRuleVersion({
+			ruleVersionId: euDraft.id,
+			approver: 'expert_1',
+		});
+		await kb.approveRuleVersion({
+			ruleVersionId: frDraft.id,
+			approver: 'expert_1',
+		});
 
-    const snapshot = await kb.publishSnapshot({
-      jurisdiction: 'EU',
-      asOfDate: new Date('2026-01-01T00:00:00.000Z'),
-    });
+		const snapshot = await kb.publishSnapshot({
+			jurisdiction: 'EU',
+			asOfDate: new Date('2026-01-01T00:00:00.000Z'),
+		});
 
-    expect(snapshot.includedRuleVersionIds).toEqual([euApproved.id]);
-  });
+		expect(snapshot.includedRuleVersionIds).toEqual([euApproved.id]);
+	});
 
-  it('search is scoped to snapshot + jurisdiction', async () => {
-    const store = createMemoryKbStore();
-    const kb = createMemoryKbHandlers(store);
+	it('search is scoped to snapshot + jurisdiction', async () => {
+		const store = createMemoryKbStore();
+		const kb = createMemoryKbHandlers(store);
 
-    await kb.createRule({
-      id: 'rule_eu',
-      jurisdiction: 'EU',
-      topicKey: 'topic',
-    });
-    const euDraft = await kb.upsertRuleVersion({
-      ruleId: 'rule_eu',
-      content: 'This is about reporting obligations',
-      sourceRefs: [{ sourceDocumentId: 'src1' }],
-    });
-    await kb.approveRuleVersion({ ruleVersionId: euDraft.id, approver: 'u1' });
-    const snap = await kb.publishSnapshot({
-      jurisdiction: 'EU',
-      asOfDate: new Date('2026-01-01T00:00:00.000Z'),
-    });
+		await kb.createRule({
+			id: 'rule_eu',
+			jurisdiction: 'EU',
+			topicKey: 'topic',
+		});
+		const euDraft = await kb.upsertRuleVersion({
+			ruleId: 'rule_eu',
+			content: 'This is about reporting obligations',
+			sourceRefs: [{ sourceDocumentId: 'src1' }],
+		});
+		await kb.approveRuleVersion({ ruleVersionId: euDraft.id, approver: 'u1' });
+		const snap = await kb.publishSnapshot({
+			jurisdiction: 'EU',
+			asOfDate: new Date('2026-01-01T00:00:00.000Z'),
+		});
 
-    await expect(
-      kb.search({ snapshotId: snap.id, jurisdiction: 'FR', query: 'reporting' })
-    ).rejects.toThrow('JURISDICTION_MISMATCH');
+		await expect(
+			kb.search({ snapshotId: snap.id, jurisdiction: 'FR', query: 'reporting' })
+		).rejects.toThrow('JURISDICTION_MISMATCH');
 
-    const ok = await kb.search({
-      snapshotId: snap.id,
-      jurisdiction: 'EU',
-      query: 'reporting',
-    });
-    expect(ok.items.map((i) => i.ruleVersionId)).toEqual([euDraft.id]);
-  });
+		const ok = await kb.search({
+			snapshotId: snap.id,
+			jurisdiction: 'EU',
+			query: 'reporting',
+		});
+		expect(ok.items.map((i) => i.ruleVersionId)).toEqual([euDraft.id]);
+	});
 });