@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/src/state-snapshot.ts

@@ -0,0 +1,291 @@
+import normalization = require('./state-snapshot-normalization');
+
+const SNAPSHOT_VERSION = 1;
+
+type UnknownRecord = Record<string, unknown>;
+
+interface SnapshotStateDraft {
+  version: number;
+  updatedAt: number;
+  clusterId: unknown;
+  sourceMessageId: unknown;
+  task?: unknown;
+  plan?: unknown;
+  progress?: unknown;
+  validation?: unknown;
+  debug?: unknown;
+}
+
+interface SnapshotState extends UnknownRecord {
+  version: number;
+  updatedAt: number;
+  clusterId: unknown;
+  sourceMessageId: unknown;
+}
+
+const {
+  LIMITS,
+  TEXT_LIMITS,
+  asRecord,
+  isPresentString,
+  toTimestamp,
+  normalizeText,
+  normalizeStringList,
+  normalizeAcceptanceCriteria,
+  normalizeCriteriaResults,
+  normalizeErrors,
+  normalizeRootCauses,
+  normalizeFilesAffected,
+  normalizeBoolean,
+  normalizeProgressStatus,
+} = normalization;
+
+function buildBaseState(state: unknown, message: unknown): SnapshotStateDraft {
+  const stateRecord = asRecord(state);
+  const messageRecord = asRecord(message);
+  return {
+    version: SNAPSHOT_VERSION,
+    updatedAt: toTimestamp(message),
+    clusterId: messageRecord?.cluster_id || stateRecord?.clusterId || null,
+    sourceMessageId: messageRecord?.id || stateRecord?.sourceMessageId || null,
+    task: stateRecord?.task,
+    plan: stateRecord?.plan,
+    progress: stateRecord?.progress,
+    validation: stateRecord?.validation,
+    debug: stateRecord?.debug,
+  };
+}
+
+function pruneEmpty(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    const next = value.map(pruneEmpty).filter((item: unknown) => item !== undefined);
+    return next.length > 0 ? next : undefined;
+  }
+  const valueRecord = asRecord(value);
+  if (valueRecord) {
+    const next: UnknownRecord = {};
+    for (const [key, entry] of Object.entries(valueRecord)) {
+      const pruned = pruneEmpty(entry);
+      if (pruned !== undefined) {
+        next[key] = pruned;
+      }
+    }
+    return Object.keys(next).length > 0 ? next : undefined;
+  }
+  if (value === undefined || value === null) return undefined;
+  return value;
+}
+
+function finalizeState(state: SnapshotStateDraft): SnapshotState {
+  const result: SnapshotState = {
+    version: state.version ?? SNAPSHOT_VERSION,
+    updatedAt: state.updatedAt ?? Date.now(),
+    clusterId: state.clusterId ?? null,
+    sourceMessageId: state.sourceMessageId ?? null,
+  };
+  const sections = asRecord(
+    pruneEmpty({
+      task: state.task,
+      plan: state.plan,
+      progress: state.progress,
+      validation: state.validation,
+      debug: state.debug,
+    })
+  );
+  if (sections) {
+    Object.assign(result, sections);
+  }
+  return result;
+}
+
+function messageContent(message: unknown): UnknownRecord {
+  return asRecord(asRecord(message)?.content) ?? {};
+}
+
+function contentData(content: UnknownRecord): UnknownRecord {
+  return asRecord(content.data) ?? {};
+}
+
+function initStateFromIssue(issueMessage: unknown): SnapshotState {
+  const messageRecord = asRecord(issueMessage);
+  const content = messageContent(issueMessage);
+  const data = contentData(content);
+  const task = {
+    raw: normalizeText(content.text, TEXT_LIMITS.task),
+    title: normalizeText(data.title, TEXT_LIMITS.summary, true),
+    issueNumber: data.issue_number ?? data.issueNumber,
+    source: asRecord(messageRecord?.metadata)?.source,
+  };
+  const base = buildBaseState(null, issueMessage);
+  base.task = pruneEmpty(task);
+  return finalizeState(base);
+}
+
+function applyIssueOpened(state: unknown, message: unknown): SnapshotState {
+  const messageRecord = asRecord(message);
+  const base = buildBaseState(state, message);
+  const content = messageContent(message);
+  const data = contentData(content);
+  const task = {
+    raw: normalizeText(content.text, TEXT_LIMITS.task),
+    title: normalizeText(data.title, TEXT_LIMITS.summary, true),
+    issueNumber: data.issue_number ?? data.issueNumber,
+    source: asRecord(messageRecord?.metadata)?.source,
+  };
+  base.task = pruneEmpty(task);
+  return finalizeState(base);
+}
+
+function applyPlanReady(state: unknown, message: unknown): SnapshotState {
+  const base = buildBaseState(state, message);
+  const content = messageContent(message);
+  const data = contentData(content);
+  const plan = {
+    text: normalizeText(content.text, TEXT_LIMITS.plan),
+    summary: normalizeText(data.summary, TEXT_LIMITS.summary, true),
+    acceptanceCriteria: normalizeAcceptanceCriteria(data.acceptanceCriteria),
+    filesAffected: normalizeFilesAffected(data.filesAffected),
+    updatedAt: toTimestamp(message),
+  };
+  base.plan = pruneEmpty(plan);
+  return finalizeState(base);
+}
+
+function applyWorkerProgress(state: unknown, message: unknown): SnapshotState {
+  const base = buildBaseState(state, message);
+  const content = messageContent(message);
+  const status = normalizeProgressStatus(content.data || {});
+  if (!status) {
+    return finalizeState(base);
+  }
+  const progress = {
+    canValidate: normalizeBoolean(status.canValidate),
+    percentComplete:
+      typeof status.percentComplete === 'number' && Number.isFinite(status.percentComplete)
+        ? status.percentComplete
+        : undefined,
+    blockers: normalizeStringList(status.blockers, LIMITS.blockers),
+    nextSteps: normalizeStringList(status.nextSteps, LIMITS.nextSteps),
+    lastSummary: normalizeText(content.text || status.summary, TEXT_LIMITS.summary, true),
+    updatedAt: toTimestamp(message),
+  };
+  base.progress = pruneEmpty(progress);
+  return finalizeState(base);
+}
+
+function applyImplementationReady(state: unknown, message: unknown): SnapshotState {
+  return applyWorkerProgress(state, message);
+}
+
+function applyValidationResult(state: unknown, message: unknown): SnapshotState {
+  const base = buildBaseState(state, message);
+  const content = messageContent(message);
+  const data = contentData(content);
+  const validation = {
+    approved: normalizeBoolean(data.approved),
+    errors: normalizeErrors(data),
+    criteriaResults: normalizeCriteriaResults(data.criteriaResults),
+    updatedAt: toTimestamp(message),
+  };
+  base.validation = pruneEmpty(validation);
+  return finalizeState(base);
+}
+
+function applyInvestigationComplete(state: unknown, message: unknown): SnapshotState {
+  const base = buildBaseState(state, message);
+  const content = messageContent(message);
+  const data = contentData(content);
+  const debug = {
+    fixPlan: normalizeText(content.text, TEXT_LIMITS.fixPlan),
+    successCriteria: normalizeText(data.successCriteria, TEXT_LIMITS.summary, true),
+    rootCauses: normalizeRootCauses(data.rootCauses),
+    updatedAt: toTimestamp(message),
+  };
+  base.debug = pruneEmpty(debug);
+  return finalizeState(base);
+}
+
+function sectionFor(state: unknown, key: string): UnknownRecord | null {
+  return asRecord(asRecord(state)?.[key]);
+}
+
+function buildTaskSummary(state: unknown): string | undefined {
+  const task = sectionFor(state, 'task');
+  const taskTitle = normalizeText(task?.title || task?.raw, TEXT_LIMITS.summary, true);
+  return taskTitle ? `Task: ${taskTitle}` : undefined;
+}
+
+function buildPlanSummary(state: unknown): string | undefined {
+  const plan = sectionFor(state, 'plan');
+  const planSummary = normalizeText(plan?.summary || plan?.text, TEXT_LIMITS.summary, true);
+  return planSummary ? `Plan: ${planSummary}` : undefined;
+}
+
+function buildProgressSummary(state: unknown): string | undefined {
+  const progress = sectionFor(state, 'progress');
+  if (!progress) return undefined;
+  const parts: string[] = [];
+  if (typeof progress.percentComplete === 'number' && Number.isFinite(progress.percentComplete)) {
+    parts.push(`${progress.percentComplete}%`);
+  }
+  if (typeof progress.canValidate === 'boolean') {
+    parts.push(`canValidate=${progress.canValidate}`);
+  }
+  const firstNextStep: unknown = Array.isArray(progress.nextSteps)
+    ? progress.nextSteps[0]
+    : undefined;
+  const nextStepText = normalizeText(firstNextStep, TEXT_LIMITS.listItem, true);
+  if (nextStepText) {
+    parts.push(`next: ${nextStepText}`);
+  }
+  return parts.length > 0 ? `Progress: ${parts.join(' | ')}` : undefined;
+}
+
+function resolveValidationStatus(approved: unknown): string {
+  if (approved === true) return 'approved';
+  if (approved === false) return 'rejected';
+  return 'pending';
+}
+
+function buildValidationSummary(state: unknown): string | undefined {
+  const validation = sectionFor(state, 'validation');
+  if (!validation) return undefined;
+  const status = resolveValidationStatus(validation.approved);
+  const errorCount = Array.isArray(validation.errors) ? validation.errors.length : 0;
+  return `Validation: ${status}${errorCount ? ` (${errorCount} errors)` : ''}`;
+}
+
+function buildDebugSummary(state: unknown): string | undefined {
+  const debug = sectionFor(state, 'debug');
+  const debugSummary = normalizeText(
+    debug?.fixPlan || debug?.successCriteria,
+    TEXT_LIMITS.summary,
+    true
+  );
+  return debugSummary ? `Debug: ${debugSummary}` : undefined;
+}
+
+function renderStateSummary(state: unknown): string {
+  if (!asRecord(state)) return '';
+  const lines = [
+    buildTaskSummary(state),
+    buildPlanSummary(state),
+    buildProgressSummary(state),
+    buildValidationSummary(state),
+    buildDebugSummary(state),
+  ].filter(isPresentString);
+
+  return lines.join('\n');
+}
+
+export = {
+  SNAPSHOT_VERSION,
+  initStateFromIssue,
+  applyIssueOpened,
+  applyPlanReady,
+  applyWorkerProgress,
+  applyImplementationReady,
+  applyValidationResult,
+  applyInvestigationComplete,
+  renderStateSummary,
+};

package/src/state-snapshotter.js

@@ -1,142 +1,130 @@
-const crypto = require('crypto');
-const {
-  initStateFromIssue,
-  applyIssueOpened,
-  applyPlanReady,
-  applyWorkerProgress,
-  applyImplementationReady,
-  applyValidationResult,
-  applyInvestigationComplete,
-  renderStateSummary,
-} = require('./state-snapshot');
-
+"use strict";
+const crypto = require("crypto");
+const stateSnapshot = require("./state-snapshot");
+const normalization = require("./state-snapshot-normalization");
 const SNAPSHOT_TOPICS = [
-  'ISSUE_OPENED',
-  'PLAN_READY',
-  'WORKER_PROGRESS',
-  'IMPLEMENTATION_READY',
-  'VALIDATION_RESULT',
-  'INVESTIGATION_COMPLETE',
+    'ISSUE_OPENED',
+    'PLAN_READY',
+    'WORKER_PROGRESS',
+    'IMPLEMENTATION_READY',
+    'VALIDATION_RESULT',
+    'INVESTIGATION_COMPLETE',
 ];
-
+function messageTimestamp(message) {
+    const timestamp = normalization.asRecord(message)?.timestamp;
+    return timestamp ? Number(timestamp) : 0;
+}
 class StateSnapshotter {
-  constructor({ messageBus, clusterId }) {
-    this.messageBus = messageBus;
-    this.clusterId = clusterId;
-    this.state = null;
-    this.lastHash = null;
-    this.unsubscribe = null;
-  }
-
-  start() {
-    if (this.unsubscribe) {
-      return;
+    messageBus;
+    clusterId;
+    state;
+    lastHash;
+    unsubscribe;
+    constructor({ messageBus, clusterId }) {
+        this.messageBus = messageBus;
+        this.clusterId = clusterId;
+        this.state = null;
+        this.lastHash = null;
+        this.unsubscribe = null;
+    }
+    start() {
+        if (this.unsubscribe) {
+            return;
+        }
+        this._bootstrapFromLedger();
+        this.unsubscribe = this.messageBus.subscribeTopics(SNAPSHOT_TOPICS, (message) => {
+            if (normalization.asRecord(message)?.cluster_id !== this.clusterId)
+                return;
+            this._handleMessage(message);
+        });
+    }
+    stop() {
+        if (!this.unsubscribe)
+            return;
+        this.unsubscribe();
+        this.unsubscribe = null;
     }
-
-    this._bootstrapFromLedger();
-
-    this.unsubscribe = this.messageBus.subscribeTopics(SNAPSHOT_TOPICS, (message) => {
-      if (message.cluster_id !== this.clusterId) return;
-      this._handleMessage(message);
-    });
-  }
-
-  stop() {
-    if (!this.unsubscribe) return;
-    this.unsubscribe();
-    this.unsubscribe = null;
-  }
-
-  _bootstrapFromLedger() {
-    const existing = this.messageBus.findLast({
-      cluster_id: this.clusterId,
-      topic: 'STATE_SNAPSHOT',
-    });
-
-    if (existing?.content?.data && typeof existing.content.data === 'object') {
-      this.state = existing.content.data;
-      this.lastHash = this._hashState(this.state);
-      return;
+    _bootstrapFromLedger() {
+        const existing = this.messageBus.findLast({
+            cluster_id: this.clusterId,
+            topic: 'STATE_SNAPSHOT',
+        });
+        const existingData = normalization.asRecord(normalization.asRecord(existing)?.content)?.data;
+        if (existingData && typeof existingData === 'object') {
+            this.state = existingData;
+            this.lastHash = this._hashState(this.state);
+            return;
+        }
+        const messages = SNAPSHOT_TOPICS.map((topic) => this.messageBus.findLast({ cluster_id: this.clusterId, topic })).filter(Boolean);
+        if (messages.length === 0) {
+            return;
+        }
+        messages.sort((left, right) => messageTimestamp(left) - messageTimestamp(right));
+        let state = null;
+        for (const message of messages) {
+            state = this._applyMessage(state, message);
+        }
+        if (state) {
+            this.state = state;
+            this._publishSnapshot(state);
+        }
     }
-
-    const messages = SNAPSHOT_TOPICS.map((topic) =>
-      this.messageBus.findLast({ cluster_id: this.clusterId, topic })
-    ).filter(Boolean);
-
-    if (messages.length === 0) {
-      return;
+    _handleMessage(message) {
+        const nextState = this._applyMessage(this.state, message);
+        if (!nextState)
+            return;
+        this.state = nextState;
+        this._publishSnapshot(nextState);
     }
-
-    messages.sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));
-
-    let state = null;
-    for (const message of messages) {
-      state = this._applyMessage(state, message);
+    _applyMessage(state, message) {
+        switch (normalization.asRecord(message)?.topic) {
+            case 'ISSUE_OPENED':
+                return state
+                    ? stateSnapshot.applyIssueOpened(state, message)
+                    : stateSnapshot.initStateFromIssue(message);
+            case 'PLAN_READY':
+                return stateSnapshot.applyPlanReady(state, message);
+            case 'WORKER_PROGRESS':
+                return stateSnapshot.applyWorkerProgress(state, message);
+            case 'IMPLEMENTATION_READY':
+                return stateSnapshot.applyImplementationReady(state, message);
+            case 'VALIDATION_RESULT':
+                return stateSnapshot.applyValidationResult(state, message);
+            case 'INVESTIGATION_COMPLETE':
+                return stateSnapshot.applyInvestigationComplete(state, message);
+            default:
+                return state;
+        }
     }
-
-    if (state) {
-      this.state = state;
-      this._publishSnapshot(state);
+    _publishSnapshot(state) {
+        const hash = this._hashState(state);
+        if (this._hashEquals(hash, this.lastHash)) {
+            return;
+        }
+        this.lastHash = hash;
+        this.messageBus.publish({
+            cluster_id: this.clusterId,
+            topic: 'STATE_SNAPSHOT',
+            sender: 'state-snapshotter',
+            receiver: 'broadcast',
+            content: {
+                text: stateSnapshot.renderStateSummary(state),
+                data: state,
+            },
+        });
     }
-  }
-
-  _handleMessage(message) {
-    const nextState = this._applyMessage(this.state, message);
-    if (!nextState) return;
-
-    this.state = nextState;
-    this._publishSnapshot(nextState);
-  }
-
-  _applyMessage(state, message) {
-    switch (message.topic) {
-      case 'ISSUE_OPENED':
-        return state ? applyIssueOpened(state, message) : initStateFromIssue(message);
-      case 'PLAN_READY':
-        return applyPlanReady(state, message);
-      case 'WORKER_PROGRESS':
-        return applyWorkerProgress(state, message);
-      case 'IMPLEMENTATION_READY':
-        return applyImplementationReady(state, message);
-      case 'VALIDATION_RESULT':
-        return applyValidationResult(state, message);
-      case 'INVESTIGATION_COMPLETE':
-        return applyInvestigationComplete(state, message);
-      default:
-        return state;
+    _hashState(state) {
+        const serialized = JSON.stringify(state);
+        return crypto.createHash('sha256').update(serialized).digest('hex');
     }
-  }
-
-  _publishSnapshot(state) {
-    const hash = this._hashState(state);
-    if (this._hashEquals(hash, this.lastHash)) {
-      return;
+    _hashEquals(left, right) {
+        if (!left || !right)
+            return false;
+        const leftBuffer = Buffer.from(left, 'utf8');
+        const rightBuffer = Buffer.from(right, 'utf8');
+        if (leftBuffer.length !== rightBuffer.length)
+            return false;
+        return crypto.timingSafeEqual(leftBuffer, rightBuffer);
     }
-    this.lastHash = hash;
-
-    this.messageBus.publish({
-      cluster_id: this.clusterId,
-      topic: 'STATE_SNAPSHOT',
-      sender: 'state-snapshotter',
-      receiver: 'broadcast',
-      content: {
-        text: renderStateSummary(state),
-        data: state,
-      },
-    });
-  }
-
-  _hashState(state) {
-    return crypto.createHash('sha256').update(JSON.stringify(state)).digest('hex');
-  }
-
-  _hashEquals(left, right) {
-    if (!left || !right) return false;
-    const leftBuffer = Buffer.from(left, 'utf8');
-    const rightBuffer = Buffer.from(right, 'utf8');
-    if (leftBuffer.length !== rightBuffer.length) return false;
-    return crypto.timingSafeEqual(leftBuffer, rightBuffer);
-  }
 }
-
 module.exports = StateSnapshotter;