@the-open-engine/zeroshot 6.38.1 → 6.39.1

package/src/state-snapshot-normalization.js

@@ -0,0 +1,224 @@
+"use strict";
+const LIMITS = {
+    errors: 5,
+    criteriaResults: 10,
+    acceptanceCriteria: 10,
+    filesAffected: 20,
+    blockers: 5,
+    nextSteps: 10,
+    rootCauses: 5,
+};
+const TEXT_LIMITS = {
+    task: 2000,
+    plan: 2500, // Slightly increased for actionable plans with embedded patterns (was 2000)
+    fixPlan: 1200,
+    summary: 300,
+    listItem: 200,
+};
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function asRecord(value) {
+    return isRecord(value) ? value : null;
+}
+function isPresentString(value) {
+    return Boolean(value);
+}
+function toTimestamp(message) {
+    const timestamp = asRecord(message)?.timestamp;
+    if (typeof timestamp === 'number' && Number.isFinite(timestamp)) {
+        return timestamp;
+    }
+    return Date.now();
+}
+function normalizeText(value, maxLength, singleLine = false) {
+    if (value === undefined || value === null)
+        return undefined;
+    let text = String(value);
+    if (singleLine) {
+        text = text.replace(/\s+/g, ' ').trim();
+    }
+    else {
+        text = text.trim();
+    }
+    if (!text)
+        return undefined;
+    if (maxLength && text.length > maxLength) {
+        return `${text.slice(0, maxLength - 3)}...`;
+    }
+    return text;
+}
+function normalizeStringList(list, maxItems) {
+    if (!Array.isArray(list))
+        return undefined;
+    const normalized = list
+        .map((item) => normalizeText(item, TEXT_LIMITS.listItem, true))
+        .filter(isPresentString);
+    if (normalized.length === 0)
+        return undefined;
+    if (maxItems && normalized.length > maxItems) {
+        return normalized.slice(-maxItems);
+    }
+    return normalized;
+}
+function normalizeAcceptanceCriteria(criteria) {
+    if (!Array.isArray(criteria))
+        return undefined;
+    const normalized = criteria
+        .map((item) => {
+        if (typeof item === 'string') {
+            return normalizeText(item, TEXT_LIMITS.listItem, true);
+        }
+        const itemRecord = asRecord(item);
+        if (!itemRecord)
+            return undefined;
+        const id = itemRecord.id ? String(itemRecord.id) : '';
+        const priority = itemRecord.priority ? ` (${String(itemRecord.priority)})` : '';
+        const criterion = itemRecord.criterion || itemRecord.text || itemRecord.summary || '';
+        const label = id ? `${id}${priority}: ` : '';
+        const merged = `${label}${String(criterion)}`.trim();
+        if (!merged)
+            return undefined;
+        return normalizeText(merged, TEXT_LIMITS.listItem, true);
+    })
+        .filter(isPresentString);
+    if (normalized.length === 0)
+        return undefined;
+    if (normalized.length > LIMITS.acceptanceCriteria) {
+        return normalized.slice(-LIMITS.acceptanceCriteria);
+    }
+    return normalized;
+}
+function normalizeCriteriaEvidence(evidence) {
+    const evidenceRecord = asRecord(evidence);
+    if (!evidenceRecord)
+        return undefined;
+    const normalized = {};
+    if (evidenceRecord.command) {
+        const command = normalizeText(evidenceRecord.command, TEXT_LIMITS.listItem, true);
+        if (command)
+            normalized.command = command;
+    }
+    if (typeof evidenceRecord.exitCode === 'number' && Number.isFinite(evidenceRecord.exitCode)) {
+        normalized.exitCode = evidenceRecord.exitCode;
+    }
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+function normalizeCriteriaResult(item) {
+    const itemRecord = asRecord(item);
+    if (!itemRecord)
+        return undefined;
+    const entry = {};
+    if (itemRecord.id)
+        entry.id = String(itemRecord.id);
+    if (itemRecord.status)
+        entry.status = String(itemRecord.status);
+    if (itemRecord.reason) {
+        const reason = normalizeText(itemRecord.reason, TEXT_LIMITS.listItem, true);
+        if (reason)
+            entry.reason = reason;
+    }
+    const evidence = normalizeCriteriaEvidence(itemRecord.evidence);
+    if (evidence)
+        entry.evidence = evidence;
+    return Object.keys(entry).length > 0 ? entry : undefined;
+}
+function isPresentRecord(value) {
+    return value !== undefined;
+}
+function normalizeCriteriaResults(results) {
+    if (!Array.isArray(results))
+        return undefined;
+    const normalized = results.map(normalizeCriteriaResult).filter(isPresentRecord);
+    if (normalized.length === 0)
+        return undefined;
+    if (normalized.length > LIMITS.criteriaResults) {
+        return normalized.slice(-LIMITS.criteriaResults);
+    }
+    return normalized;
+}
+function normalizeErrors(data) {
+    const dataRecord = asRecord(data);
+    if (!dataRecord)
+        return undefined;
+    if (Array.isArray(dataRecord.errors)) {
+        return normalizeStringList(dataRecord.errors, LIMITS.errors);
+    }
+    if (Array.isArray(dataRecord.issues)) {
+        const mapped = dataRecord.issues.map((issue) => {
+            if (typeof issue === 'string')
+                return issue;
+            const issueRecord = asRecord(issue);
+            if (!issueRecord)
+                return undefined;
+            return (issueRecord.bug ||
+                issueRecord.message ||
+                issueRecord.error ||
+                issueRecord.summary ||
+                undefined);
+        });
+        return normalizeStringList(mapped, LIMITS.errors);
+    }
+    return undefined;
+}
+function normalizeRootCauses(rootCauses) {
+    if (!Array.isArray(rootCauses))
+        return undefined;
+    const normalized = rootCauses
+        .map((cause) => {
+        if (typeof cause === 'string') {
+            return normalizeText(cause, TEXT_LIMITS.listItem, true);
+        }
+        const causeRecord = asRecord(cause);
+        if (!causeRecord)
+            return undefined;
+        return normalizeText(causeRecord.cause || causeRecord.summary || causeRecord.description, TEXT_LIMITS.listItem, true);
+    })
+        .filter(isPresentString);
+    if (normalized.length === 0)
+        return undefined;
+    if (normalized.length > LIMITS.rootCauses) {
+        return normalized.slice(-LIMITS.rootCauses);
+    }
+    return normalized;
+}
+function normalizeFilesAffected(filesAffected) {
+    return normalizeStringList(filesAffected, LIMITS.filesAffected);
+}
+function normalizeBoolean(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    return undefined;
+}
+function normalizeProgressStatus(data) {
+    const dataRecord = asRecord(data);
+    if (!dataRecord)
+        return undefined;
+    const completionStatus = asRecord(dataRecord.completionStatus);
+    if (completionStatus) {
+        return completionStatus;
+    }
+    const hasProgressFields = Object.prototype.hasOwnProperty.call(dataRecord, 'canValidate') ||
+        Object.prototype.hasOwnProperty.call(dataRecord, 'percentComplete');
+    return hasProgressFields ? dataRecord : undefined;
+}
+module.exports = {
+    LIMITS,
+    TEXT_LIMITS,
+    asRecord,
+    isPresentString,
+    toTimestamp,
+    normalizeText,
+    normalizeStringList,
+    normalizeAcceptanceCriteria,
+    normalizeCriteriaResults,
+    normalizeErrors,
+    normalizeRootCauses,
+    normalizeFilesAffected,
+    normalizeBoolean,
+    normalizeProgressStatus,
+};

package/src/state-snapshot-normalization.ts

@@ -0,0 +1,222 @@
+type UnknownRecord = Record<string, unknown>;
+
+const LIMITS = {
+  errors: 5,
+  criteriaResults: 10,
+  acceptanceCriteria: 10,
+  filesAffected: 20,
+  blockers: 5,
+  nextSteps: 10,
+  rootCauses: 5,
+};
+
+const TEXT_LIMITS = {
+  task: 2000,
+  plan: 2500, // Slightly increased for actionable plans with embedded patterns (was 2000)
+  fixPlan: 1200,
+  summary: 300,
+  listItem: 200,
+};
+
+function isRecord(value: unknown): value is UnknownRecord {
+  return typeof value === 'object' && value !== null;
+}
+
+function asRecord(value: unknown): UnknownRecord | null {
+  return isRecord(value) ? value : null;
+}
+
+function isPresentString(value: string | undefined): value is string {
+  return Boolean(value);
+}
+
+function toTimestamp(message: unknown): number {
+  const timestamp = asRecord(message)?.timestamp;
+  if (typeof timestamp === 'number' && Number.isFinite(timestamp)) {
+    return timestamp;
+  }
+  return Date.now();
+}
+
+function normalizeText(value: unknown, maxLength: number, singleLine = false): string | undefined {
+  if (value === undefined || value === null) return undefined;
+  let text = String(value);
+  if (singleLine) {
+    text = text.replace(/\s+/g, ' ').trim();
+  } else {
+    text = text.trim();
+  }
+  if (!text) return undefined;
+  if (maxLength && text.length > maxLength) {
+    return `${text.slice(0, maxLength - 3)}...`;
+  }
+  return text;
+}
+
+function normalizeStringList(list: unknown, maxItems: number): string[] | undefined {
+  if (!Array.isArray(list)) return undefined;
+  const normalized = list
+    .map((item: unknown) => normalizeText(item, TEXT_LIMITS.listItem, true))
+    .filter(isPresentString);
+  if (normalized.length === 0) return undefined;
+  if (maxItems && normalized.length > maxItems) {
+    return normalized.slice(-maxItems);
+  }
+  return normalized;
+}
+
+function normalizeAcceptanceCriteria(criteria: unknown): string[] | undefined {
+  if (!Array.isArray(criteria)) return undefined;
+  const normalized = criteria
+    .map((item: unknown) => {
+      if (typeof item === 'string') {
+        return normalizeText(item, TEXT_LIMITS.listItem, true);
+      }
+      const itemRecord = asRecord(item);
+      if (!itemRecord) return undefined;
+      const id = itemRecord.id ? String(itemRecord.id) : '';
+      const priority = itemRecord.priority ? ` (${String(itemRecord.priority)})` : '';
+      const criterion = itemRecord.criterion || itemRecord.text || itemRecord.summary || '';
+      const label = id ? `${id}${priority}: ` : '';
+      const merged = `${label}${String(criterion)}`.trim();
+      if (!merged) return undefined;
+      return normalizeText(merged, TEXT_LIMITS.listItem, true);
+    })
+    .filter(isPresentString);
+  if (normalized.length === 0) return undefined;
+  if (normalized.length > LIMITS.acceptanceCriteria) {
+    return normalized.slice(-LIMITS.acceptanceCriteria);
+  }
+  return normalized;
+}
+
+function normalizeCriteriaEvidence(evidence: unknown): UnknownRecord | undefined {
+  const evidenceRecord = asRecord(evidence);
+  if (!evidenceRecord) return undefined;
+  const normalized: UnknownRecord = {};
+  if (evidenceRecord.command) {
+    const command = normalizeText(evidenceRecord.command, TEXT_LIMITS.listItem, true);
+    if (command) normalized.command = command;
+  }
+  if (typeof evidenceRecord.exitCode === 'number' && Number.isFinite(evidenceRecord.exitCode)) {
+    normalized.exitCode = evidenceRecord.exitCode;
+  }
+  return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+
+function normalizeCriteriaResult(item: unknown): UnknownRecord | undefined {
+  const itemRecord = asRecord(item);
+  if (!itemRecord) return undefined;
+  const entry: UnknownRecord = {};
+  if (itemRecord.id) entry.id = String(itemRecord.id);
+  if (itemRecord.status) entry.status = String(itemRecord.status);
+  if (itemRecord.reason) {
+    const reason = normalizeText(itemRecord.reason, TEXT_LIMITS.listItem, true);
+    if (reason) entry.reason = reason;
+  }
+  const evidence = normalizeCriteriaEvidence(itemRecord.evidence);
+  if (evidence) entry.evidence = evidence;
+  return Object.keys(entry).length > 0 ? entry : undefined;
+}
+
+function isPresentRecord(value: UnknownRecord | undefined): value is UnknownRecord {
+  return value !== undefined;
+}
+
+function normalizeCriteriaResults(results: unknown): UnknownRecord[] | undefined {
+  if (!Array.isArray(results)) return undefined;
+  const normalized = results.map(normalizeCriteriaResult).filter(isPresentRecord);
+  if (normalized.length === 0) return undefined;
+  if (normalized.length > LIMITS.criteriaResults) {
+    return normalized.slice(-LIMITS.criteriaResults);
+  }
+  return normalized;
+}
+
+function normalizeErrors(data: unknown): string[] | undefined {
+  const dataRecord = asRecord(data);
+  if (!dataRecord) return undefined;
+  if (Array.isArray(dataRecord.errors)) {
+    return normalizeStringList(dataRecord.errors, LIMITS.errors);
+  }
+  if (Array.isArray(dataRecord.issues)) {
+    const mapped = dataRecord.issues.map((issue: unknown) => {
+      if (typeof issue === 'string') return issue;
+      const issueRecord = asRecord(issue);
+      if (!issueRecord) return undefined;
+      return (
+        issueRecord.bug ||
+        issueRecord.message ||
+        issueRecord.error ||
+        issueRecord.summary ||
+        undefined
+      );
+    });
+    return normalizeStringList(mapped, LIMITS.errors);
+  }
+  return undefined;
+}
+
+function normalizeRootCauses(rootCauses: unknown): string[] | undefined {
+  if (!Array.isArray(rootCauses)) return undefined;
+  const normalized = rootCauses
+    .map((cause: unknown) => {
+      if (typeof cause === 'string') {
+        return normalizeText(cause, TEXT_LIMITS.listItem, true);
+      }
+      const causeRecord = asRecord(cause);
+      if (!causeRecord) return undefined;
+      return normalizeText(
+        causeRecord.cause || causeRecord.summary || causeRecord.description,
+        TEXT_LIMITS.listItem,
+        true
+      );
+    })
+    .filter(isPresentString);
+  if (normalized.length === 0) return undefined;
+  if (normalized.length > LIMITS.rootCauses) {
+    return normalized.slice(-LIMITS.rootCauses);
+  }
+  return normalized;
+}
+
+function normalizeFilesAffected(filesAffected: unknown): string[] | undefined {
+  return normalizeStringList(filesAffected, LIMITS.filesAffected);
+}
+
+function normalizeBoolean(value: unknown): boolean | undefined {
+  if (typeof value === 'boolean') return value;
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  return undefined;
+}
+
+function normalizeProgressStatus(data: unknown): UnknownRecord | undefined {
+  const dataRecord = asRecord(data);
+  if (!dataRecord) return undefined;
+  const completionStatus = asRecord(dataRecord.completionStatus);
+  if (completionStatus) {
+    return completionStatus;
+  }
+  const hasProgressFields =
+    Object.prototype.hasOwnProperty.call(dataRecord, 'canValidate') ||
+    Object.prototype.hasOwnProperty.call(dataRecord, 'percentComplete');
+  return hasProgressFields ? dataRecord : undefined;
+}
+
+export = {
+  LIMITS,
+  TEXT_LIMITS,
+  asRecord,
+  isPresentString,
+  toTimestamp,
+  normalizeText,
+  normalizeStringList,
+  normalizeAcceptanceCriteria,
+  normalizeCriteriaResults,
+  normalizeErrors,
+  normalizeRootCauses,
+  normalizeFilesAffected,
+  normalizeBoolean,
+  normalizeProgressStatus,
+};