@tryvitris/website-harness 0.0.0-stage → 0.1.0-beta.5

package/bin/chunks/chunk-M4LNHYYR.js

@@ -0,0 +1,177 @@
+// src/engine/contracts.ts
+var ENGINE_CONTRACT_VERSION = 1;
+var object = (value, name) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${name} must be an object`);
+  return value;
+};
+var string = (value, name) => {
+  if (typeof value !== "string" || !value.trim()) throw new Error(`${name} must be a non-empty string`);
+  return value;
+};
+var assertRequestId = (value) => {
+  const id = string(value, "requestId");
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(id)) throw new Error("requestId must be a safe single path segment");
+  return id;
+};
+var strings = (value, name) => {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || !item.trim())) throw new Error(`${name} must be an array of non-empty strings`);
+  return value;
+};
+var oneOf = (value, name, options) => {
+  if (!options.includes(value)) throw new Error(`${name} is invalid`);
+  return value;
+};
+var version = (record, name) => {
+  if (record.schemaVersion !== ENGINE_CONTRACT_VERSION) throw new Error(`${name} schemaVersion must be 1`);
+};
+function parseSiteIdentity(value) {
+  const r = object(value, "site identity");
+  version(r, "site identity");
+  const h = object(r.harness, "harness");
+  const name = oneOf(h.name, "harness.name", ["@tryvitris/website-harness", "@tryvitris/harness", "@vitris/harness"]);
+  if (!Number.isInteger(r.sourceFormatVersion) || Number(r.sourceFormatVersion) < 1) throw new Error("sourceFormatVersion must be positive");
+  return {
+    schemaVersion: 1,
+    siteId: string(r.siteId, "siteId"),
+    sourceFormatVersion: Number(r.sourceFormatVersion),
+    harness: { name, version: string(h.version, "harness.version") },
+    capabilities: strings(r.capabilities, "capabilities")
+  };
+}
+function parseSourceRevision(value) {
+  const r = object(value, "source revision");
+  version(r, "source revision");
+  const digest = string(r.digest, "digest");
+  if (!/^[a-f0-9]{64}$/.test(digest)) throw new Error("digest must be SHA-256");
+  if (!Array.isArray(r.inputs)) throw new Error("inputs must be an array");
+  const inputs = r.inputs.map((item, index) => {
+    const i = object(item, `inputs[${index}]`);
+    const sha256 = string(i.sha256, `inputs[${index}].sha256`);
+    if (!/^[a-f0-9]{64}$/.test(sha256) || !Number.isInteger(i.bytes) || Number(i.bytes) < 0) throw new Error(`inputs[${index}] has invalid hash or size`);
+    return { path: string(i.path, `inputs[${index}].path`), sha256, bytes: Number(i.bytes) };
+  });
+  return { schemaVersion: 1, digest, inputs, ...r.gitHead === void 0 ? {} : { gitHead: string(r.gitHead, "gitHead") } };
+}
+function parseChangeRequest(value) {
+  const r = object(value, "change request");
+  version(r, "change request");
+  const facets = ["business", "copy", "pages", "direction", "media"];
+  if (!Array.isArray(r.requestedScopes)) throw new Error("requestedScopes must be an array");
+  if (!Array.isArray(r.explicitPreferences)) throw new Error("explicitPreferences must be an array");
+  return {
+    schemaVersion: 1,
+    id: assertRequestId(r.id),
+    instruction: string(r.instruction, "instruction"),
+    origin: oneOf(r.origin, "origin", ["operator", "agent", "editor", "hosted"]),
+    baseRevision: string(r.baseRevision, "baseRevision"),
+    requestedScopes: r.requestedScopes.map((s, i) => oneOf(s, `requestedScopes[${i}]`, facets)),
+    explicitPreferences: r.explicitPreferences.map((item, i) => {
+      const p = object(item, `explicitPreferences[${i}]`);
+      return {
+        intent: oneOf(p.intent, "intent", ["positive", "negative", "preserve"]),
+        text: string(p.text, "preference text"),
+        ...p.target === void 0 ? {} : { target: string(p.target, "preference target") }
+      };
+    }),
+    evidence: strings(r.evidence, "evidence")
+  };
+}
+function parseChangePlan(value) {
+  const r = object(value, "change plan");
+  version(r, "change plan");
+  if (!Array.isArray(r.targets) || r.targets.length === 0 || !Array.isArray(r.files) || r.files.length === 0) throw new Error("plan targets and files must be non-empty");
+  if (!Array.isArray(r.facets) || r.facets.length === 0) throw new Error("plan facets must be non-empty");
+  if (!Array.isArray(r.acceptanceCriteria) || r.acceptanceCriteria.length === 0) throw new Error("acceptanceCriteria must be non-empty");
+  if (!Array.isArray(r.requiredChecks) || r.requiredChecks.length === 0) throw new Error("requiredChecks must be non-empty");
+  const facets = ["business", "copy", "pages", "direction", "media"];
+  const criteria = r.acceptanceCriteria.map((item, i) => {
+    const a = object(item, `acceptanceCriteria[${i}]`);
+    return {
+      id: string(a.id, "criterion id"),
+      kind: oneOf(a.kind, "criterion kind", ["exact_text", "absence", "visual_review", "semantic_review", "interaction"]),
+      target: string(a.target, "criterion target"),
+      ...a.expected === void 0 ? {} : { expected: string(a.expected, "expected") }
+    };
+  });
+  if (new Set(criteria.map((c) => c.id)).size !== criteria.length) throw new Error("acceptance criterion IDs must be unique");
+  return {
+    schemaVersion: 1,
+    requestId: assertRequestId(r.requestId),
+    baseRevision: string(r.baseRevision, "baseRevision"),
+    targets: strings(r.targets, "targets"),
+    files: strings(r.files, "files"),
+    facets: r.facets.map((f, i) => oneOf(f, `facets[${i}]`, facets)),
+    preserve: strings(r.preserve, "preserve"),
+    acceptanceCriteria: criteria,
+    requiredChecks: strings(r.requiredChecks, "requiredChecks"),
+    assumptions: strings(r.assumptions, "assumptions"),
+    evidence: strings(r.evidence, "evidence"),
+    proposedBy: oneOf(r.proposedBy, "proposedBy", ["active_agent", "operator", "editor"])
+  };
+}
+function parseVerificationReceipt(value) {
+  const r = object(value, "verification receipt");
+  version(r, "verification receipt");
+  if (!Array.isArray(r.checks)) throw new Error("checks must be an array");
+  return {
+    schemaVersion: 1,
+    subjectRevision: string(r.subjectRevision, "subjectRevision"),
+    buildDigest: string(r.buildDigest, "buildDigest"),
+    checks: r.checks.map((item, i) => {
+      const c = object(item, `checks[${i}]`);
+      return {
+        id: string(c.id, "check id"),
+        version: string(c.version, "check version"),
+        outcome: oneOf(c.outcome, "check outcome", ["pass", "fail", "unevaluated"]),
+        evidence: strings(c.evidence, "check evidence")
+      };
+    }),
+    reviewer: oneOf(r.reviewer, "reviewer", ["machine", "active_agent", "independent_model", "human"]),
+    createdAt: string(r.createdAt, "createdAt")
+  };
+}
+function parseChangeResult(value) {
+  const r = object(value, "change result");
+  version(r, "change result");
+  const outcomes = ["pass", "fail", "unevaluated"];
+  return {
+    schemaVersion: 1,
+    requestId: string(r.requestId, "requestId"),
+    beforeRevision: string(r.beforeRevision, "beforeRevision"),
+    afterRevision: string(r.afterRevision, "afterRevision"),
+    changedTargets: strings(r.changedTargets, "changedTargets"),
+    changedFiles: strings(r.changedFiles, "changedFiles"),
+    technical: oneOf(r.technical, "technical", outcomes),
+    fulfillment: oneOf(r.fulfillment, "fulfillment", outcomes),
+    design: oneOf(r.design, "design", outcomes),
+    unresolved: strings(r.unresolved, "unresolved"),
+    ...r.previewDigest === void 0 ? {} : { previewDigest: string(r.previewDigest, "previewDigest") },
+    ...r.receipt === void 0 ? {} : { receipt: parseVerificationReceipt(r.receipt) }
+  };
+}
+function parseReleaseRecord(value) {
+  const r = object(value, "release record");
+  version(r, "release record");
+  return {
+    schemaVersion: 1,
+    sourceRevision: string(r.sourceRevision, "sourceRevision"),
+    buildDigest: string(r.buildDigest, "buildDigest"),
+    compilerDigest: string(r.compilerDigest, "compilerDigest"),
+    harnessVersion: string(r.harnessVersion, "harnessVersion"),
+    policyId: string(r.policyId, "policyId"),
+    environment: string(r.environment, "environment"),
+    deploymentReceipt: string(r.deploymentReceipt, "deploymentReceipt")
+  };
+}
+
+export {
+  ENGINE_CONTRACT_VERSION,
+  assertRequestId,
+  parseSiteIdentity,
+  parseSourceRevision,
+  parseChangeRequest,
+  parseChangePlan,
+  parseVerificationReceipt,
+  parseChangeResult,
+  parseReleaseRecord
+};

package/bin/chunks/chunk-PRLL7B63.js

@@ -0,0 +1,113 @@
+// src/agent/jev/state.ts
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+function buildGroundingState(item) {
+  return {
+    task: "grounding",
+    claimId: item.claimId,
+    claim: item.claim.trim(),
+    evidenceId: item.evidenceId,
+    sourceFile: item.sourceFile,
+    excerpt: item.excerpt.trim()
+  };
+}
+function buildRoutingState(instruction, options) {
+  return {
+    task: "routing",
+    instruction: instruction.trim(),
+    currentPages: options?.pages,
+    preservedDecisions: options?.preserved
+  };
+}
+function buildCtaState(opts) {
+  return {
+    task: "cta_consistency",
+    pagePath: opts.pagePath,
+    sectionId: opts.sectionId,
+    plannedCta: opts.plannedCta.trim(),
+    storyboardAction: opts.storyboardAction
+  };
+}
+function sha256Hex(str) {
+  return createHash("sha256").update(str).digest("hex");
+}
+function simpleHash(str) {
+  return sha256Hex(str);
+}
+function buildSharedGroundingBatch(candidates) {
+  const claims = {};
+  const evidence = {};
+  const evidenceKeyByHash = /* @__PURE__ */ new Map();
+  let evCounter = 0;
+  for (const c of candidates) {
+    if (c.claimId && c.claim) {
+      if (!claims[c.claimId]) {
+        claims[c.claimId] = {
+          id: c.claimId,
+          claim: c.claim.trim()
+        };
+      }
+    }
+    const normExcerpt = c.excerpt.trim();
+    const hash = sha256Hex(normExcerpt);
+    const sourceLoc = {
+      source: c.source || c.sourceFile || "",
+      span: c.span,
+      ...c.alias !== void 0 ? { alias: c.alias } : {},
+      ...c.evidenceId !== void 0 ? { evidenceId: c.evidenceId } : {},
+      ...c.sourceFile !== void 0 ? { sourceFile: c.sourceFile } : {}
+    };
+    if (!evidenceKeyByHash.has(hash)) {
+      const evKey = `ev_${evCounter++}`;
+      evidenceKeyByHash.set(hash, evKey);
+      evidence[evKey] = {
+        id: c.evidenceId || evKey,
+        source: c.source || c.sourceFile || "",
+        hash,
+        excerpt: normExcerpt,
+        sources: [sourceLoc]
+      };
+    } else {
+      const evKey = evidenceKeyByHash.get(hash);
+      const existing = evidence[evKey];
+      existing.sources ||= [];
+      if (!existing.sources.some((s) => s.source === sourceLoc.source && JSON.stringify(s.span) === JSON.stringify(sourceLoc.span) && s.alias === sourceLoc.alias)) {
+        existing.sources.push(sourceLoc);
+      }
+    }
+  }
+  return {
+    state: {
+      task: "grounding_batch",
+      claims,
+      evidence
+    },
+    evidenceKeyByHash,
+    evidence: Object.values(evidence)
+  };
+}
+function rehashOverflowContent(overflowPath) {
+  const bytes = readFileSync(overflowPath);
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function bindBatchToPreparation(state, preparationId, nodeId) {
+  return {
+    ...state,
+    metadata: {
+      ...state.metadata || {},
+      preparationId,
+      nodeId
+    }
+  };
+}
+
+export {
+  buildGroundingState,
+  buildRoutingState,
+  buildCtaState,
+  sha256Hex,
+  simpleHash,
+  buildSharedGroundingBatch,
+  rehashOverflowContent,
+  bindBatchToPreparation
+};