@lssm/example.kb-update-pipeline 0.0.0-canary-20251213172311

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

@@ -0,0 +1,80 @@
+import { describe, expect, it } from 'bun:test';
+
+import { createPipelineMemoryHandlers, createPipelineMemoryStore } from './memory.handlers';
+
+describe('@lssm/example.kb-update-pipeline memory handlers', () => {
+  it('high-risk change cannot be approved by curator role', async () => {
+    const store = createPipelineMemoryStore();
+    const pipeline = createPipelineMemoryHandlers(store);
+
+    store.candidates.set('c1', {
+      id: 'c1',
+      sourceDocumentId: 'EU_src1',
+      detectedAt: new Date(),
+      diffSummary: 'Change detected',
+      riskLevel: 'high',
+    });
+
+    const review = await pipeline.createReviewTask({ changeCandidateId: 'c1' });
+    await expect(
+      pipeline.submitDecision({
+        reviewTaskId: review.id,
+        decision: 'approve',
+        decidedBy: 'u_curator',
+        decidedByRole: 'curator',
+      })
+    ).rejects.toThrow('FORBIDDEN_ROLE');
+  });
+
+  it('fires a notification when review is requested', async () => {
+    const store = createPipelineMemoryStore();
+    const pipeline = createPipelineMemoryHandlers(store);
+
+    store.candidates.set('c2', {
+      id: 'c2',
+      sourceDocumentId: 'EU_src2',
+      detectedAt: new Date(),
+      diffSummary: 'Minor change',
+      riskLevel: 'low',
+    });
+
+    const review = await pipeline.createReviewTask({ changeCandidateId: 'c2' });
+    expect(store.notifications.length).toBe(1);
+    expect(store.notifications[0]?.reviewTaskId).toBe(review.id);
+    expect(store.notifications[0]?.assignedRole).toBe('curator');
+  });
+
+  it('publishing fails if any included rule versions are not approved', async () => {
+    const store = createPipelineMemoryStore();
+    const pipeline = createPipelineMemoryHandlers(store);
+
+    store.candidates.set('c3', {
+      id: 'c3',
+      sourceDocumentId: 'EU_src3',
+      detectedAt: new Date(),
+      diffSummary: 'Change',
+      riskLevel: 'low',
+    });
+
+    const review = await pipeline.createReviewTask({ changeCandidateId: 'c3' });
+    await pipeline.proposeRulePatch({
+      changeCandidateId: 'c3',
+      proposedRuleVersionIds: ['rv1', 'rv2'],
+    });
+    await pipeline.submitDecision({
+      reviewTaskId: review.id,
+      decision: 'approve',
+      decidedBy: 'u_curator',
+      decidedByRole: 'curator',
+    });
+
+    // only approve one of the proposed rule versions
+    await pipeline.markRuleVersionApproved({ ruleVersionId: 'rv1' });
+
+    await expect(
+      pipeline.publishIfReady({ jurisdiction: 'EU' })
+    ).rejects.toThrow('NOT_READY');
+  });
+});
+
+

package/src/handlers/memory.handlers.ts

@@ -0,0 +1,180 @@
+type ChangeCandidate = {
+  id: string;
+  sourceDocumentId: string;
+  detectedAt: Date;
+  diffSummary: string;
+  riskLevel: 'low' | 'medium' | 'high';
+};
+
+type ReviewTask = {
+  id: string;
+  changeCandidateId: string;
+  status: 'open' | 'decided';
+  assignedRole: 'curator' | 'expert';
+  decision?: 'approve' | 'reject';
+  decidedAt?: Date;
+  decidedBy?: string;
+};
+
+export interface PipelineMemoryStore {
+  candidates: Map<string, ChangeCandidate>;
+  reviewTasks: Map<string, ReviewTask>;
+  proposedRuleVersionIdsByCandidate: Map<string, string[]>;
+  approvedRuleVersionIds: Set<string>;
+  notifications: Array<{
+    kind: 'kb.review.requested';
+    reviewTaskId: string;
+    changeCandidateId: string;
+    assignedRole: 'curator' | 'expert';
+    createdAt: Date;
+  }>;
+}
+
+export function createPipelineMemoryStore(): PipelineMemoryStore {
+  return {
+    candidates: new Map(),
+    reviewTasks: new Map(),
+    proposedRuleVersionIdsByCandidate: new Map(),
+    approvedRuleVersionIds: new Set(),
+    notifications: [],
+  };
+}
+
+function stableId(prefix: string, value: string): string {
+  return `${prefix}_${value.replace(/[^a-zA-Z0-9_-]/g, '_')}`;
+}
+
+export interface PipelineMemoryHandlers {
+  runWatch(input: { jurisdiction: string }): Promise<{ candidates: ChangeCandidate[] }>;
+  createReviewTask(input: { changeCandidateId: string }): Promise<ReviewTask>;
+  proposeRulePatch(input: {
+    changeCandidateId: string;
+    proposedRuleVersionIds: string[];
+  }): Promise<{ proposedRuleVersionIds: string[] }>;
+  markRuleVersionApproved(input: { ruleVersionId: string }): Promise<{ ruleVersionId: string }>;
+  submitDecision(input: {
+    reviewTaskId: string;
+    decision: 'approve' | 'reject';
+    decidedBy: string;
+    decidedByRole: 'curator' | 'expert';
+  }): Promise<ReviewTask>;
+  publishIfReady(input: { jurisdiction: string }): Promise<{ published: boolean; reason?: string }>;
+}
+
+export function createPipelineMemoryHandlers(
+  store: PipelineMemoryStore
+): PipelineMemoryHandlers {
+  async function runWatch(input: { jurisdiction: string }) {
+    // demo: always returns empty unless caller pre-seeds candidates
+    const candidates = [...store.candidates.values()].filter(
+      (c) => c.sourceDocumentId.startsWith(`${input.jurisdiction}_`) || true
+    );
+    return { candidates };
+  }
+
+  async function createReviewTask(input: { changeCandidateId: string }) {
+    const candidate = store.candidates.get(input.changeCandidateId);
+    if (!candidate) throw new Error('CHANGE_CANDIDATE_NOT_FOUND');
+    const assignedRole = candidate.riskLevel === 'high' ? 'expert' : 'curator';
+    const id = stableId('review', input.changeCandidateId);
+    const task: ReviewTask = {
+      id,
+      changeCandidateId: input.changeCandidateId,
+      status: 'open',
+      assignedRole,
+      decision: undefined,
+      decidedAt: undefined,
+      decidedBy: undefined,
+    };
+    store.reviewTasks.set(id, task);
+    store.notifications.push({
+      kind: 'kb.review.requested',
+      reviewTaskId: id,
+      changeCandidateId: input.changeCandidateId,
+      assignedRole,
+      createdAt: new Date(),
+    });
+    return task;
+  }
+
+  async function proposeRulePatch(input: {
+    changeCandidateId: string;
+    proposedRuleVersionIds: string[];
+  }): Promise<{ proposedRuleVersionIds: string[] }> {
+    if (!store.candidates.has(input.changeCandidateId)) {
+      throw new Error('CHANGE_CANDIDATE_NOT_FOUND');
+    }
+    store.proposedRuleVersionIdsByCandidate.set(
+      input.changeCandidateId,
+      [...input.proposedRuleVersionIds]
+    );
+    return { proposedRuleVersionIds: [...input.proposedRuleVersionIds] };
+  }
+
+  async function markRuleVersionApproved(input: {
+    ruleVersionId: string;
+  }): Promise<{ ruleVersionId: string }> {
+    store.approvedRuleVersionIds.add(input.ruleVersionId);
+    return { ruleVersionId: input.ruleVersionId };
+  }
+
+  async function submitDecision(input: {
+    reviewTaskId: string;
+    decision: 'approve' | 'reject';
+    decidedBy: string;
+    decidedByRole: 'curator' | 'expert';
+  }) {
+    const task = store.reviewTasks.get(input.reviewTaskId);
+    if (!task) throw new Error('REVIEW_TASK_NOT_FOUND');
+    const candidate = store.candidates.get(task.changeCandidateId);
+    if (!candidate) throw new Error('CHANGE_CANDIDATE_NOT_FOUND');
+    if (candidate.riskLevel === 'high' && input.decision === 'approve') {
+      if (input.decidedByRole !== 'expert') throw new Error('FORBIDDEN_ROLE');
+    }
+    const decided: ReviewTask = {
+      ...task,
+      status: 'decided',
+      decision: input.decision,
+      decidedAt: new Date(),
+      decidedBy: input.decidedBy,
+    };
+    store.reviewTasks.set(decided.id, decided);
+    return decided;
+  }
+
+  async function publishIfReady(_input: { jurisdiction: string }) {
+    const openTasks = [...store.reviewTasks.values()].filter(
+      (t) => t.status !== 'decided'
+    );
+    if (openTasks.length) {
+      throw new Error('NOT_READY');
+    }
+    const rejected = [...store.reviewTasks.values()].some(
+      (t) => t.decision === 'reject'
+    );
+    if (rejected) return { published: false, reason: 'REJECTED' };
+
+    // Ensure every proposed rule version is approved before publishing.
+    for (const task of store.reviewTasks.values()) {
+      if (task.decision !== 'approve') continue;
+      const proposed =
+        store.proposedRuleVersionIdsByCandidate.get(task.changeCandidateId) ?? [];
+      const unapproved = proposed.filter((id) => !store.approvedRuleVersionIds.has(id));
+      if (unapproved.length) {
+        throw new Error('NOT_READY');
+      }
+    }
+    return { published: true };
+  }
+
+  return {
+    runWatch,
+    createReviewTask,
+    proposeRulePatch,
+    markRuleVersionApproved,
+    submitDecision,
+    publishIfReady,
+  };
+}
+
+

package/src/index.ts

@@ -0,0 +1,15 @@
+/**
+ * KB Update Pipeline Example
+ *
+ * Automation proposes KB updates; humans verify; everything audited and notified.
+ */
+export * from './entities';
+export * from './contracts';
+export * from './events';
+export * from './handlers';
+export * from './feature';
+export { default as example } from './example';
+
+import './docs';
+
+

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "@lssm/tool.typescript/react-library.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
+
+