@contractspec/example.versioned-knowledge-base 1.57.0 → 1.58.0

package/dist/events.d.ts

@@ -1,63 +1,57 @@
-import * as _contractspec_lib_contracts0 from "@contractspec/lib.contracts";
-import * as _contractspec_lib_schema0 from "@contractspec/lib.schema";
-
-//#region src/events.d.ts
-declare const KbSourceIngestedEvent: _contractspec_lib_contracts0.EventSpec<_contractspec_lib_schema0.SchemaModel<{
-  sourceDocumentId: {
-    type: _contractspec_lib_schema0.FieldType<string, string>;
-    isOptional: false;
-  };
-  jurisdiction: {
-    type: _contractspec_lib_schema0.FieldType<string, string>;
-    isOptional: false;
-  };
-  hash: {
-    type: _contractspec_lib_schema0.FieldType<string, string>;
-    isOptional: false;
-  };
+export declare const KbSourceIngestedEvent: import("@contractspec/lib.contracts").EventSpec<import("@contractspec/lib.schema").SchemaModel<{
+    sourceDocumentId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    jurisdiction: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    hash: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
 }>>;
-declare const KbRuleVersionCreatedEvent: _contractspec_lib_contracts0.EventSpec<_contractspec_lib_schema0.SchemaModel<{
-  ruleVersionId: {
-    type: _contractspec_lib_schema0.FieldType<string, string>;
-    isOptional: false;
-  };
-  ruleId: {
-    type: _contractspec_lib_schema0.FieldType<string, string>;
-    isOptional: false;
-  };
-  jurisdiction: {
-    type: _contractspec_lib_schema0.FieldType<string, string>;
-    isOptional: false;
-  };
-  status: {
-    type: _contractspec_lib_schema0.FieldType<string, string>;
-    isOptional: false;
-  };
+export declare const KbRuleVersionCreatedEvent: import("@contractspec/lib.contracts").EventSpec<import("@contractspec/lib.schema").SchemaModel<{
+    ruleVersionId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    ruleId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    jurisdiction: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    status: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
 }>>;
-declare const KbRuleVersionApprovedEvent: _contractspec_lib_contracts0.EventSpec<_contractspec_lib_schema0.SchemaModel<{
-  ruleVersionId: {
-    type: _contractspec_lib_schema0.FieldType<string, string>;
-    isOptional: false;
-  };
-  approver: {
-    type: _contractspec_lib_schema0.FieldType<string, string>;
-    isOptional: false;
-  };
+export declare const KbRuleVersionApprovedEvent: import("@contractspec/lib.contracts").EventSpec<import("@contractspec/lib.schema").SchemaModel<{
+    ruleVersionId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    approver: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
 }>>;
-declare const KbSnapshotPublishedEvent: _contractspec_lib_contracts0.EventSpec<_contractspec_lib_schema0.SchemaModel<{
-  snapshotId: {
-    type: _contractspec_lib_schema0.FieldType<string, string>;
-    isOptional: false;
-  };
-  jurisdiction: {
-    type: _contractspec_lib_schema0.FieldType<string, string>;
-    isOptional: false;
-  };
-  includedRuleVersionsCount: {
-    type: _contractspec_lib_schema0.FieldType<number, number>;
-    isOptional: false;
-  };
+export declare const KbSnapshotPublishedEvent: import("@contractspec/lib.contracts").EventSpec<import("@contractspec/lib.schema").SchemaModel<{
+    snapshotId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    jurisdiction: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    includedRuleVersionsCount: {
+        type: import("@contractspec/lib.schema").FieldType<number, number>;
+        isOptional: false;
+    };
 }>>;
-//#endregion
-export { KbRuleVersionApprovedEvent, KbRuleVersionCreatedEvent, KbSnapshotPublishedEvent, KbSourceIngestedEvent };
 //# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"events.d.ts","names":[],"sources":["../src/events.ts"],"mappings":";;;;cAgBa,qBAAA,EAAqB,4BAAA,CAAA,SAAA,2BAAA,WAAA;;UAUhC,yBAAA,CAAA,SAAA;;;;;;;;;;;;cAgBW,yBAAA,EAAyB,4BAAA,CAAA,SAAA,2BAAA,WAAA;;UAUpC,yBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;cAcW,0BAAA,EAA0B,4BAAA,CAAA,SAAA,2BAAA,WAAA;;UAUrC,yBAAA,CAAA,SAAA;;;;;;;;cAeW,wBAAA,EAAwB,4BAAA,CAAA,SAAA,2BAAA,WAAA;;UAUnC,yBAAA,CAAA,SAAA"}
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;GAUhC,CAAC;AAgBH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;GAUpC,CAAC;AAcH,eAAO,MAAM,0BAA0B;;;;;;;;;GAUrC,CAAC;AAeH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;GAUnC,CAAC"}

package/dist/events.js

@@ -1,124 +1,102 @@
+// @bun
+// src/events.ts
 import { defineEvent, defineSchemaModel } from "@contractspec/lib.contracts";
 import { ScalarTypeEnum } from "@contractspec/lib.schema";
-
-//#region src/events.ts
-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
-		}
-	}
+var 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 }
+  }
 });
-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
+var KbSourceIngestedEvent = defineEvent({
+  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
-		}
-	}
+var 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 }
+  }
 });
-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
+var KbRuleVersionCreatedEvent = defineEvent({
+  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
-		}
-	}
+var 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 }
+  }
 });
-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
+var 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
 });
-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
-		}
-	}
+var 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
+    }
+  }
 });
-const KbSnapshotPublishedEvent = defineEvent({
-	meta: {
-		key: "kb.snapshot.published",
-		version: "1.0.0",
-		description: "KB snapshot published.",
-		stability: "experimental",
-		owners: ["@examples"],
-		tags: ["knowledge"]
-	},
-	payload: KbSnapshotPublishedPayload
+var KbSnapshotPublishedEvent = defineEvent({
+  meta: {
+    key: "kb.snapshot.published",
+    version: "1.0.0",
+    description: "KB snapshot published.",
+    stability: "experimental",
+    owners: ["@examples"],
+    tags: ["knowledge"]
+  },
+  payload: KbSnapshotPublishedPayload
 });
-
-//#endregion
-export { KbRuleVersionApprovedEvent, KbRuleVersionCreatedEvent, KbSnapshotPublishedEvent, KbSourceIngestedEvent };
-//# sourceMappingURL=events.js.map
+export {
+  KbSourceIngestedEvent,
+  KbSnapshotPublishedEvent,
+  KbRuleVersionCreatedEvent,
+  KbRuleVersionApprovedEvent
+};

package/dist/example.d.ts

@@ -1,7 +1,3 @@
-import * as _contractspec_lib_contracts0 from "@contractspec/lib.contracts";
-
-//#region src/example.d.ts
-declare const example: _contractspec_lib_contracts0.ExampleSpec;
-//#endregion
-export { example as default };
+declare const example: import("@contractspec/lib.contracts").ExampleSpec;
+export default example;
 //# sourceMappingURL=example.d.ts.map

package/dist/example.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"example.d.ts","names":[],"sources":["../src/example.ts"],"mappings":";;;cAEM,OAAA,EA6BJ,4BAAA,CA7BW,WAAA"}
+{"version":3,"file":"example.d.ts","sourceRoot":"","sources":["../src/example.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,OAAO,mDA6BX,CAAC;AAEH,eAAe,OAAO,CAAC"}

package/dist/example.js

@@ -1,48 +1,36 @@
+// @bun
+// src/example.ts
 import { defineExample } from "@contractspec/lib.contracts";
-
-//#region src/example.ts
-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 }
-	}
+var 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 }
+  }
 });
-
-//#endregion
-export { example as default };
-//# sourceMappingURL=example.js.map
+var example_default = example;
+export {
+  example_default as default
+};

package/dist/handlers/index.d.ts

@@ -1,2 +1,2 @@
-import { MemoryKbHandlers, MemoryKbStore, createMemoryKbHandlers, createMemoryKbStore } from "./memory.handlers.js";
-export { MemoryKbHandlers, MemoryKbStore, createMemoryKbHandlers, createMemoryKbStore };
+export * from './memory.handlers';
+//# sourceMappingURL=index.d.ts.map

package/dist/handlers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/handlers/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/handlers/index.js

@@ -1,3 +1,116 @@
-import { createMemoryKbHandlers, createMemoryKbStore } from "./memory.handlers.js";
-
-export { createMemoryKbHandlers, createMemoryKbStore };
+// @bun
+// src/handlers/memory.handlers.ts
+function createMemoryKbStore() {
+  return {
+    sources: new Map,
+    rules: new Map,
+    ruleVersions: new Map,
+    snapshots: new Map,
+    nextRuleVersionNumberByRuleId: new Map
+  };
+}
+function stableId(prefix, value) {
+  return `${prefix}_${value.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+}
+function createMemoryKbHandlers(store) {
+  async function createRule(rule) {
+    store.rules.set(rule.id, rule);
+    return rule;
+  }
+  async function ingestSource(input) {
+    const id = stableId("src", `${input.jurisdiction}_${input.hash}`);
+    const doc = { id, ...input };
+    store.sources.set(id, doc);
+    return doc;
+  }
+  async function upsertRuleVersion(input) {
+    if (!input.sourceRefs.length) {
+      throw new Error("SOURCE_REFS_REQUIRED");
+    }
+    const rule = store.rules.get(input.ruleId);
+    if (!rule) {
+      throw new Error("RULE_NOT_FOUND");
+    }
+    const next = (store.nextRuleVersionNumberByRuleId.get(input.ruleId) ?? 0) + 1;
+    const id = stableId("rv", `${input.ruleId}_${next}`);
+    const ruleVersion = {
+      id,
+      ruleId: input.ruleId,
+      jurisdiction: rule.jurisdiction,
+      topicKey: rule.topicKey,
+      version: next.toString(),
+      content: input.content,
+      sourceRefs: input.sourceRefs,
+      status: "draft",
+      createdAt: new Date,
+      approvedAt: undefined,
+      approvedBy: undefined
+    };
+    store.ruleVersions.set(id, ruleVersion);
+    return ruleVersion;
+  }
+  async function approveRuleVersion(input) {
+    const existing = store.ruleVersions.get(input.ruleVersionId);
+    if (!existing) {
+      throw new Error("RULE_VERSION_NOT_FOUND");
+    }
+    const approved = {
+      ...existing,
+      status: "approved",
+      approvedBy: input.approver,
+      approvedAt: new Date
+    };
+    store.ruleVersions.set(approved.id, approved);
+    return approved;
+  }
+  async function publishSnapshot(input) {
+    const approved = [...store.ruleVersions.values()].filter((rv) => rv.status === "approved" && rv.jurisdiction === input.jurisdiction);
+    if (approved.length === 0) {
+      throw new Error("NO_APPROVED_RULES");
+    }
+    const includedRuleVersionIds = approved.map((rv) => rv.id).sort();
+    const id = stableId("snap", `${input.jurisdiction}_${input.asOfDate.toISOString().slice(0, 10)}_${includedRuleVersionIds.length}`);
+    const snapshot = {
+      id,
+      jurisdiction: input.jurisdiction,
+      asOfDate: input.asOfDate,
+      includedRuleVersionIds,
+      publishedAt: new Date
+    };
+    store.snapshots.set(id, snapshot);
+    return snapshot;
+  }
+  async function search(input) {
+    const snapshot = store.snapshots.get(input.snapshotId);
+    if (!snapshot) {
+      throw new Error("SNAPSHOT_NOT_FOUND");
+    }
+    if (snapshot.jurisdiction !== input.jurisdiction) {
+      throw new Error("JURISDICTION_MISMATCH");
+    }
+    const q = input.query.toLowerCase();
+    const tokens = q.split(/\s+/).map((t) => t.trim()).filter(Boolean);
+    const items = snapshot.includedRuleVersionIds.map((id) => store.ruleVersions.get(id)).filter((rv) => Boolean(rv)).filter((rv) => {
+      if (tokens.length === 0)
+        return true;
+      const hay = rv.content.toLowerCase();
+      return tokens.every((token) => hay.includes(token));
+    }).map((rv) => ({
+      ruleVersionId: rv.id,
+      excerpt: rv.content.slice(0, 120)
+    }));
+    return { items };
+  }
+  return {
+    createRule,
+    ingestSource,
+    upsertRuleVersion,
+    approveRuleVersion,
+    publishSnapshot,
+    search
+  };
+}
+export {
+  createMemoryKbStore,
+  createMemoryKbHandlers
+};