@wix/agent-skills 1.36.0 → 1.36.1

package/skills/wix-replatform/lib/app-page-routing.js

@@ -1,75 +0,0 @@
-'use strict';
-
-// A capability is enabled by payload and read-back evidence for this exact page family.
-// Served support is a separate post-frontend result, never inferred from a successful write.
-function validateCapability(row) {
-  if (!row || typeof row !== 'object' || !row.family || !row.frontendType) throw new Error('route capability needs family and frontendType');
-  if (row.supported) {
-    for (const key of ['key', 'pageIdentifier', 'pageIdentifierType', 'variable', 'readMethod', 'writeMethod', 'evidence']) {
-      if (typeof row[key] !== 'string' || !row[key]) throw new Error(`supported route capability ${row.family} missing ${key}`);
-    }
-    if (!['tpaPageId', 'pageId'].includes(row.pageIdentifierType)) throw new Error('unsupported pageIdentifierType');
-    if (!row.request || row.request.urlMapping?.pageIdentifier !== row.pageIdentifier || row.request.urlMapping?.pageIdentifierType !== row.pageIdentifierType || !row.readBackFixture || row.readBackFixture.pageIdentifier !== row.pageIdentifier || row.readBackFixture.mapping !== row.request.urlMapping.mapping) {
-      throw new Error(`supported route capability ${row.family} needs matching request and read-back fixture`);
-    }
-  }
-  return row;
-}
-
-function inspectRoute(source, capability, existing) {
-  validateCapability(capability);
-  if (!source || source.family !== capability.family || !source.pattern) throw new Error('route source needs matching family and pattern');
-  if (!capability.supported) return { ...source, status: 'unverified', reason: capability.reason || 'missing-adapter-evidence' };
-  if (!source.pattern.includes(`{{${capability.variable}}}`) || /[?#]/.test(source.pattern)) {
-    return { ...source, status: 'unverified', reason: 'unsupported-source-pattern' };
-  }
-  if (existing && existing.owner && existing.owner !== capability.key) {
-    return { ...source, status: 'conflict', reason: 'occupied-address', existing };
-  }
-  if (existing && existing.mapping === source.pattern && existing.pageIdentifier === capability.pageIdentifier) {
-    return { ...source, status: 'reused', readBack: existing, served: false };
-  }
-  if (existing && existing.mapping && existing.mapping !== source.pattern) {
-    return { ...source, status: 'conflict', reason: 'different-existing-mapping', existing };
-  }
-  return { ...source, status: 'write-required', existing: existing || null, served: false };
-}
-
-async function configureRoute(plan, capability, transport) {
-  if (plan.status !== 'write-required') return plan;
-  validateCapability(capability);
-  if (!capability.supported) throw new Error('unsupported capability cannot write');
-  if (!transport || typeof transport.write !== 'function' || typeof transport.read !== 'function') throw new Error('route transport needs write and read');
-  const payload = {
-    key: capability.key,
-    urlMapping: {
-      key: capability.key,
-      pageIdentifier: capability.pageIdentifier,
-      pageIdentifierType: capability.pageIdentifierType,
-      mapping: plan.pattern,
-    },
-  };
-  await transport.write(payload, capability, { mode: plan.existing ? 'update' : 'create' });
-  const readBack = await transport.read(capability.key, capability);
-  if (!readBack || readBack.mapping !== plan.pattern || readBack.pageIdentifier !== capability.pageIdentifier) {
-    return { ...plan, status: 'readback-failed', payload, readBack: readBack || null, served: false };
-  }
-  return { ...plan, status: 'configured', payload, readBack, served: false };
-}
-
-function expectedPath(pattern, slug) {
-  if (!pattern || typeof slug !== 'string' || !slug || !pattern.includes('{{slug}}')) throw new Error('read-back pattern and slug required');
-  const path = `/${pattern.replace(/^\/+/, '').replace('{{slug}}', encodeURIComponent(slug))}`;
-  if (path.includes('{{')) throw new Error('unresolved route variable');
-  return path;
-}
-
-function verifyServedRoute(result, check) {
-  if (!['configured', 'reused'].includes(result.status)) return result;
-  if (!check || !check.deploymentId || !check.targetRecordId || !check.path || !check.identityMatched || !check.generatedUrlMatched) {
-    return { ...result, served: false, servedReason: check && check.reason || 'route-identity-unverified' };
-  }
-  return { ...result, served: true, servedEvidence: check };
-}
-
-module.exports = { validateCapability, inspectRoute, configureRoute, expectedPath, verifyServedRoute };

package/skills/wix-replatform/lib/artifact-freshness.js

@@ -1,225 +0,0 @@
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-const crypto = require('node:crypto');
-
-const SCHEMA_VERSION = 1;
-
-const DEFAULT_ARTIFACTS = {
-  sourceSchema: 'source-schema.json',
-  mappingPlan: 'mapping/mapping-plan.json',
-  setupVerification: 'setup/setup-verification.json',
-  generatedImportCode: 'src/import',
-};
-
-function sha256Text(text) {
-  return crypto.createHash('sha256').update(text).digest('hex');
-}
-
-function fileHash(filePath) {
-  if (!fs.existsSync(filePath)) return null;
-  const stat = fs.statSync(filePath);
-  if (!stat.isFile()) return null;
-  return sha256Text(fs.readFileSync(filePath));
-}
-
-function directoryHash(dirPath) {
-  if (!fs.existsSync(dirPath)) return null;
-  const entries = listFilesRecursive(dirPath)
-    .map((file) => {
-      const relative = path.relative(dirPath, file).replace(/\\/g, '/');
-      return `${relative}\0${fileHash(file)}`;
-    })
-    .join('\n');
-  return sha256Text(entries);
-}
-
-function listFilesRecursive(root) {
-  const files = [];
-  const entries = fs.readdirSync(root, { withFileTypes: true })
-    .filter((entry) => !entry.name.startsWith('.'))
-    .sort((a, b) => a.name.localeCompare(b.name));
-  for (const entry of entries) {
-    const fullPath = path.join(root, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...listFilesRecursive(fullPath));
-    } else if (entry.isFile()) {
-      files.push(fullPath);
-    }
-  }
-  return files;
-}
-
-function hashArtifact(projectDir, relativePath) {
-  if (!relativePath) return null;
-  const absolute = path.resolve(projectDir, relativePath);
-  if (!fs.existsSync(absolute)) return null;
-  const stat = fs.statSync(absolute);
-  if (stat.isDirectory()) return directoryHash(absolute);
-  if (stat.isFile()) return fileHash(absolute);
-  return null;
-}
-
-function targetLedgerRevision(domainsDir) {
-  if (!domainsDir || !fs.existsSync(domainsDir)) return null;
-  return directoryHash(domainsDir);
-}
-
-function createFreshnessMetadata({
-  projectDir,
-  domainsDir,
-  artifactPaths = DEFAULT_ARTIFACTS,
-  generatedImportCodeRevision = null,
-  createdAt = new Date().toISOString(),
-} = {}) {
-  if (!projectDir) throw new Error('projectDir is required');
-  const additional = {};
-  const schemaFile = path.join(projectDir, 'source-schema.json');
-  const schema = fs.existsSync(schemaFile) ? JSON.parse(fs.readFileSync(schemaFile, 'utf8')) : {};
-  const entities = Array.isArray(schema.entities) ? schema.entities : Object.values(schema.entities || {});
-  if (entities.some((entity) => entity.sourceMeta?.extractionPlan)) {
-    const { planFreshnessReferences } = require('../resources/rp-source-wordpress/lib/plugin-entity-read-plan.js');
-    for (const reference of planFreshnessReferences({ projectDir, entities })) additional[`pluginInput:${reference.path}`] = { path: reference.path, sha256: hashArtifact(projectDir, reference.path) };
-    for (const input of ['src/extract', 'src/lib', 'src/project', 'src/import/plugin-handoff.js']) additional[`pluginCode:${input}`] = { path: input, sha256: hashArtifact(projectDir, input) };
-  }
-  return {
-    schemaVersion: SCHEMA_VERSION,
-    createdAt,
-    artifacts: {
-      ...additional,
-      sourceSchema: {
-        path: artifactPaths.sourceSchema || DEFAULT_ARTIFACTS.sourceSchema,
-        sha256: hashArtifact(projectDir, artifactPaths.sourceSchema || DEFAULT_ARTIFACTS.sourceSchema),
-      },
-      mappingPlan: {
-        path: artifactPaths.mappingPlan || DEFAULT_ARTIFACTS.mappingPlan,
-        sha256: hashArtifact(projectDir, artifactPaths.mappingPlan || DEFAULT_ARTIFACTS.mappingPlan),
-      },
-      setupVerification: {
-        path: artifactPaths.setupVerification || DEFAULT_ARTIFACTS.setupVerification,
-        sha256: hashArtifact(projectDir, artifactPaths.setupVerification || DEFAULT_ARTIFACTS.setupVerification),
-      },
-      generatedImportCode: {
-        path: artifactPaths.generatedImportCode || DEFAULT_ARTIFACTS.generatedImportCode,
-        sha256: hashArtifact(projectDir, artifactPaths.generatedImportCode || DEFAULT_ARTIFACTS.generatedImportCode),
-        revision: generatedImportCodeRevision,
-      },
-    },
-    targetContractLedger: {
-      path: domainsDir || null,
-      revision: targetLedgerRevision(domainsDir),
-    },
-  };
-}
-
-function compareFreshnessMetadata(current, recorded) {
-  const changes = [];
-  if (!recorded || typeof recorded !== 'object') {
-    return { ok: false, stale: true, changes: [{ field: 'metadata', reason: 'missing' }] };
-  }
-  if (recorded.schemaVersion !== SCHEMA_VERSION) {
-    changes.push({ field: 'schemaVersion', expected: SCHEMA_VERSION, actual: recorded.schemaVersion });
-  }
-  for (const name of new Set([...Object.keys(current.artifacts || {}), ...Object.keys(recorded.artifacts || {})])) {
-    const currentEntry = current.artifacts[name] || {};
-    const recordedEntry = (recorded.artifacts && recorded.artifacts[name]) || {};
-    if (currentEntry.sha256 !== recordedEntry.sha256) {
-      changes.push({
-        field: `artifacts.${name}.sha256`,
-        path: currentEntry.path || recordedEntry.path || null,
-        expected: recordedEntry.sha256 || null,
-        actual: currentEntry.sha256 || null,
-      });
-    }
-    if (name === 'generatedImportCode' && currentEntry.revision !== recordedEntry.revision) {
-      changes.push({
-        field: 'artifacts.generatedImportCode.revision',
-        expected: recordedEntry.revision || null,
-        actual: currentEntry.revision || null,
-      });
-    }
-  }
-  const currentLedger = current.targetContractLedger || {};
-  const recordedLedger = recorded.targetContractLedger || {};
-  if (currentLedger.revision !== recordedLedger.revision) {
-    changes.push({
-      field: 'targetContractLedger.revision',
-      path: currentLedger.path || recordedLedger.path || null,
-      expected: recordedLedger.revision || null,
-      actual: currentLedger.revision || null,
-    });
-  }
-  return { ok: changes.length === 0, stale: changes.length > 0, changes };
-}
-
-function validateImportPlanFreshness({
-  projectDir,
-  domainsDir,
-  metadataPath = 'execution/review/import-plan.freshness.json',
-  artifactPaths = DEFAULT_ARTIFACTS,
-  generatedImportCodeRevision = null,
-} = {}) {
-  const absoluteMetadataPath = path.resolve(projectDir, metadataPath);
-  const current = createFreshnessMetadata({
-    projectDir,
-    domainsDir,
-    artifactPaths,
-    generatedImportCodeRevision,
-  });
-  if (!fs.existsSync(absoluteMetadataPath)) {
-    return {
-      ok: false,
-      stale: true,
-      current,
-      recorded: null,
-      changes: [{ field: metadataPath, reason: 'missing' }],
-    };
-  }
-  const recorded = JSON.parse(fs.readFileSync(absoluteMetadataPath, 'utf8'));
-  const comparison = compareFreshnessMetadata(current, recorded);
-  return { ...comparison, current, recorded };
-}
-
-function writeFreshnessMetadata(filePath, metadata) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, `${JSON.stringify(metadata, null, 2)}\n`);
-}
-
-function renderImportPlanDelta({ staleResult, generatedAt = new Date().toISOString() }) {
-  const lines = [
-    '# Import Plan Delta',
-    '',
-    `Generated: ${generatedAt}`,
-    '',
-    'The approved import plan is stale relative to current artifacts.',
-    '',
-    '## Changed Assumptions',
-    '',
-  ];
-  for (const change of staleResult.changes || []) {
-    const pathPart = change.path ? ` (${change.path})` : '';
-    const reasonPart = change.reason ? `: ${change.reason}` : '';
-    lines.push(`- ${change.field}${pathPart}${reasonPart}`);
-  }
-  lines.push('', 'Regenerate `execution/review/import-plan.md` or accept this delta before live writes/final reporting.');
-  return `${lines.join('\n')}\n`;
-}
-
-function writeImportPlanDelta(filePath, staleResult) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, renderImportPlanDelta({ staleResult }));
-}
-
-module.exports = {
-  SCHEMA_VERSION,
-  DEFAULT_ARTIFACTS,
-  createFreshnessMetadata,
-  compareFreshnessMetadata,
-  validateImportPlanFreshness,
-  writeFreshnessMetadata,
-  renderImportPlanDelta,
-  writeImportPlanDelta,
-  hashArtifact,
-  targetLedgerRevision,
-};