avorelo 0.1.0

package/scripts/lib/adapter-readiness.js

@@ -0,0 +1,417 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const CONTRACT = "avorelo.adapterReadiness.v1";
+const SCHEMA_VERSION = 1;
+
+const READINESS_DIR_REL = ".claude/cco/orchestration/adapter-readiness";
+const LATEST_READINESS_REL = `${READINESS_DIR_REL}/latest-readiness.json`;
+
+// Host detection config — expanded to all 7 hosts (PR #163)
+const HOST_CONFIGS = Object.freeze([
+  {
+    host: "cli",
+    label: "CLI (local)",
+    configPaths: [],
+    hookConfigPath: null,
+    markers: [],
+    fallback: true,
+    alwaysAvailable: true,
+  },
+  {
+    host: "claude_code",
+    label: "Claude Code",
+    configPaths: [".claude/settings.json", ".claude/settings.local.json"],
+    hookConfigPath: ".claude/settings.json",
+    markers: [".claude"],
+  },
+  {
+    host: "codex",
+    label: "Codex CLI",
+    configPaths: ["codex.yaml", ".codex/config.yaml"],
+    hookConfigPath: null,
+    markers: ["codex.yaml", ".codex"],
+    partialOnly: true,
+  },
+  {
+    host: "vscode",
+    label: "VS Code",
+    configPaths: [".vscode/settings.json"],
+    hookConfigPath: null,
+    markers: [".vscode"],
+    partialOnly: true,
+  },
+  {
+    host: "cursor",
+    label: "Cursor",
+    configPaths: [".cursor/settings.json"],
+    hookConfigPath: null,
+    markers: [".cursor"],
+    partialOnly: true,
+  },
+  {
+    host: "openhands",
+    label: "OpenHands",
+    configPaths: [".openhands/config.yaml", ".openhands/hooks.json"],
+    hookConfigPath: ".openhands/hooks.json",
+    markers: [".openhands"],
+    unsupportedUnlessDetected: true,
+  },
+  {
+    host: "unknown",
+    label: "Unknown/Generic",
+    configPaths: [],
+    hookConfigPath: null,
+    markers: [],
+    fallback: true,
+  },
+]);
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function safeWriteJson(filePath, data) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+}
+
+function safeExists(p) {
+  try {
+    return fs.existsSync(p);
+  } catch {
+    return false;
+  }
+}
+
+function safeReadJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function detectHost(cwd, hostConfig) {
+  if (hostConfig.fallback) {
+    return {
+      host: hostConfig.host,
+      label: hostConfig.label,
+      detected: false, // generic_cli is a fallback, not detected via markers
+      fallback: true,
+    };
+  }
+
+  for (const marker of hostConfig.markers) {
+    if (safeExists(path.join(cwd, marker))) {
+      return {
+        host: hostConfig.host,
+        label: hostConfig.label,
+        detected: true,
+        fallback: false,
+      };
+    }
+  }
+
+  return {
+    host: hostConfig.host,
+    label: hostConfig.label,
+    detected: false,
+    fallback: false,
+  };
+}
+
+function inspectHostConfig(cwd, hostConfig) {
+  const detection = detectHost(cwd, hostConfig);
+  const result = {
+    host: hostConfig.host,
+    label: hostConfig.label,
+    detected: detection.detected,
+    fallback: detection.fallback || false,
+    configPath: hostConfig.hookConfigPath,
+    existingConfig: null,
+    configValid: null,
+    safeToAutoModify: false, // Always false — never auto-modify
+    previewAvailable: false,
+    reasonCodes: [],
+  };
+
+  if (!detection.detected && !detection.fallback) {
+    result.reasonCodes.push("HOST_NOT_DETECTED");
+    return result;
+  }
+
+  // Check for existing hook config
+  if (hostConfig.hookConfigPath) {
+    const configAbs = path.join(cwd, hostConfig.hookConfigPath);
+    if (safeExists(configAbs)) {
+      const parsed = safeReadJson(configAbs);
+      if (parsed !== null) {
+        result.existingConfig = { present: true, valid: true, redacted: true };
+        result.configValid = true;
+        result.reasonCodes.push("CONFIG_FOUND", "CONFIG_VALID");
+      } else {
+        result.existingConfig = { present: true, valid: false, redacted: true };
+        result.configValid = false;
+        result.reasonCodes.push("CONFIG_FOUND", "CONFIG_INVALID_JSON");
+      }
+    } else {
+      result.existingConfig = { present: false };
+      result.configValid = null;
+      result.reasonCodes.push("NO_EXISTING_CONFIG");
+    }
+    // Preview is available for any detected host with a known config path
+    result.previewAvailable = true;
+  }
+
+  if (detection.fallback) {
+    result.previewAvailable = true;
+    result.reasonCodes.push("GENERIC_CLI_FALLBACK");
+  }
+
+  return result;
+}
+
+function detectAdapterReadiness(cwd, options = {}) {
+  const hosts = HOST_CONFIGS.map((hc) => inspectHostConfig(cwd, hc));
+
+  const detectedHosts = hosts.filter((h) => h.detected && !h.fallback);
+  const hasDetected = detectedHosts.length > 0;
+
+  let status;
+  if (hasDetected) {
+    const allValid = detectedHosts.every((h) => h.configValid !== false);
+    const anyInvalid = detectedHosts.some((h) => h.configValid === false);
+    if (anyInvalid) {
+      status = "needs_review";
+    } else {
+      status = "partial"; // detected but hooks not installed yet
+    }
+  } else {
+    status = "partial"; // generic_cli fallback available
+  }
+
+  return { hosts, status, hasDetected };
+}
+
+// ── Adapter Signal Collection (PR #163) ──────────────────────────────────────
+
+function collectAdapterSignals(cwd, options) {
+  options = options || {};
+  function safeArtifact(rel) {
+    try {
+      const p = path.join(cwd, rel);
+      if (!fs.existsSync(p)) return null;
+      return JSON.parse(fs.readFileSync(p, "utf8").replace(/^/, ""));
+    } catch { return null; }
+  }
+  return {
+    hostCapabilityMatrix: safeArtifact(".claude/cco/orchestration/adapter-readiness/latest-host-capability-matrix.json"),
+    crossHostInstall: safeArtifact(".claude/cco/orchestration/adapter-readiness/latest-cross-host-install.json"),
+    crossHostInstallPlan: safeArtifact(".claude/cco/orchestration/adapter-readiness/latest-install-plan.json"),
+    crossHostValueFlow: safeArtifact(".claude/cco/orchestration/adapter-readiness/latest-cross-host-value-flow.json"),
+    adapterSafetyBoundaries: safeArtifact(".claude/cco/orchestration/adapter-readiness/latest-adapter-safety-boundaries.json"),
+    hostSupportContext: safeArtifact(".claude/cco/orchestration/adapter-readiness/latest-host-support-context.json"),
+    browserProofPreflight: safeArtifact(".claude/cco/orchestration/adapter-readiness/latest-browser-proof-preflight.json"),
+    technicalGate: safeArtifact(".claude/cco/orchestration/adapter-readiness/latest-technical-gate.json"),
+    supportBundle: safeArtifact(".claude/cco/support/latest-support-bundle.json"),
+  };
+}
+
+function scoreAdapterReadiness(signals, options) {
+  options = options || {};
+  // If technical gate is available, use its score
+  if (signals && signals.technicalGate && typeof signals.technicalGate.score === "number") {
+    return {
+      score: signals.technicalGate.score,
+      verdict: signals.technicalGate.verdict || (signals.technicalGate.score >= 90 ? "adapter_ready" : signals.technicalGate.score >= 60 ? "adapter_partial" : "adapter_not_ready"),
+      basis: "technical_gate",
+    };
+  }
+  // Compute from sub-signal statuses
+  const weights = { adapterSafetyBoundaries: 25, crossHostValueFlow: 20, hostCapabilityMatrix: 15, crossHostInstall: 15, hostSupportContext: 15, browserProofPreflight: 10 };
+  const statusScore = { pass: 1.0, warn: 0.5, blocked: 0.0, info: 1.0 };
+  let earned = 0;
+  const total = Object.values(weights).reduce(function(a, b) { return a + b; }, 0);
+  Object.keys(weights).forEach(function(key) {
+    const sig = signals && signals[key];
+    const s = (sig && sig.status) || "warn";
+    earned += weights[key] * (statusScore[s] != null ? statusScore[s] : 0.5);
+  });
+  const score = Math.round((earned / total) * 100);
+  return {
+    score,
+    verdict: score >= 90 ? "adapter_ready" : score >= 60 ? "adapter_partial" : "adapter_not_ready",
+    basis: "signal_aggregation",
+  };
+}
+
+function detectHostCapabilities(cwd, options) {
+  // Returns per-host detection + capabilities from host-capability-matrix if available
+  try {
+    const { HOST_DEFS, inspectHostCapabilities } = require("./host-capability-matrix");
+    return HOST_DEFS.map(function(def) { return inspectHostCapabilities(cwd, def); });
+  } catch (e) {
+    // Fallback: use local HOST_CONFIGS
+    return HOST_CONFIGS.map(function(hc) { return inspectHostConfig(cwd, hc); });
+  }
+}
+
+function classifyHostStatus(hostConfig, inspected) {
+  // cli/unknown/generic_cli fallback: always ready
+  if (hostConfig.alwaysAvailable || hostConfig.host === "cli" || hostConfig.host === "unknown") return "ready";
+  if (inspected.detected) {
+    // Never claim fully "ready" without verified evidence — use "partial"
+    return "partial";
+  }
+  // Not detected
+  if (hostConfig.unsupportedUnlessDetected) return "unsupported";
+  if (hostConfig.partialOnly) return "unknown";
+  return "unknown";
+}
+
+function buildAdapterReadiness(cwd, options = {}) {
+  const { hosts, status: detectedStatus, hasDetected } = detectAdapterReadiness(cwd, options);
+  const signals = collectAdapterSignals(cwd, options);
+  const { score, verdict, basis } = scoreAdapterReadiness(signals, options);
+
+  // Build hostStatuses from detection
+  const hostStatuses = {};
+  HOST_CONFIGS.forEach(function(hc) {
+    const inspected = hosts.find(function(h) { return h.host === hc.host; }) || { detected: false };
+    hostStatuses[hc.host] = classifyHostStatus(hc, inspected);
+  });
+
+  const readyHosts = Object.keys(hostStatuses).filter(function(k) { return hostStatuses[k] === "ready"; });
+  const partialHosts = Object.keys(hostStatuses).filter(function(k) { return hostStatuses[k] === "partial"; });
+  const unsupportedHosts = Object.keys(hostStatuses).filter(function(k) { return hostStatuses[k] === "unsupported"; });
+
+  const blockers = [];
+  const warnings = [];
+
+  // CLI must always be ready
+  if (!readyHosts.includes("cli")) {
+    blockers.push({ id: "cli_not_ready", message: "CLI host is not available — local path broken." });
+  }
+  if (unsupportedHosts.length > 0) {
+    warnings.push({ id: "unsupported_hosts", message: "Unsupported hosts caveated: " + unsupportedHosts.join(", ") });
+  }
+  if (score < 60 && !blockers.length) {
+    warnings.push({ id: "low_score", message: "Adapter readiness score " + score + "/100 — run sub-module commands to improve." });
+  }
+
+  const status = blockers.length > 0 ? "blocked" : (score >= 90 && !warnings.length) ? "pass" : "warn";
+
+  let recommendedNextPr;
+  if (blockers.length > 0) recommendedNextPr = "Repair: CLI adapter path broken";
+  else if (score >= 90) recommendedNextPr = "Alpha Launch Candidate Prep";
+  else if (score >= 60) recommendedNextPr = "Run cross-host sub-module commands to improve score";
+  else recommendedNextPr = "Run: node bin/avorelo adapter-readiness-technical --json";
+
+  const recommendedMode = "preview_only";
+  let nextAction;
+  if (detectedStatus === "needs_review") {
+    nextAction = "Review invalid config file(s) before applying hook preview.";
+  } else if (hasDetected) {
+    nextAction = "Review the generated hook config preview. Apply requires explicit user approval.";
+  } else {
+    nextAction = "No host adapter detected. CLI fallback available.";
+  }
+
+  return {
+    contract: CONTRACT,
+    schemaVersion: SCHEMA_VERSION,
+    createdAt: nowIso(),
+    status,
+    score,
+    verdict,
+    scoreBasis: basis,
+    hosts,
+    hostStatuses,
+    readyHosts,
+    partialHosts,
+    unsupportedHosts,
+    blockers,
+    warnings,
+    recommendedNextPr,
+    recommendedMode,
+    nextAction,
+    approvalRequiredBeforeApply: true,
+    noWorksEverywhereClaim: true,
+    noPublicLaunchClaim: true,
+    redacted: true,
+  };
+}
+
+function writeAdapterReadiness(cwd, readiness) {
+  const absPath = path.join(cwd, LATEST_READINESS_REL);
+  ensureDir(path.dirname(absPath));
+  safeWriteJson(absPath, readiness);
+  return { path: LATEST_READINESS_REL, written: true };
+}
+
+function buildAdapterReadinessSurface(cwd, options = {}) {
+  const readiness = buildAdapterReadiness(cwd, options);
+  const writeResult = writeAdapterReadiness(cwd, readiness);
+  return { readiness, writeResult };
+}
+
+function formatAdapterReadinessText(readiness, options = {}) {
+  const debug = options.debug || false;
+  const lines = [`Avorelo adapter readiness: ${readiness.status}.`, ""];
+
+  const detected = (readiness.hosts || []).filter((h) => h.detected && !h.fallback);
+  const fallback = (readiness.hosts || []).filter((h) => h.fallback);
+
+  if (detected.length > 0) {
+    lines.push("Detected hosts:");
+    for (const h of detected) {
+      const configNote = h.existingConfig && h.existingConfig.present && h.existingConfig.valid
+        ? "existing config valid"
+        : h.existingConfig && h.existingConfig.present && h.existingConfig.valid === false
+        ? "existing config invalid — needs review"
+        : "no existing config";
+      lines.push(`  - ${h.label}: ${configNote}`);
+    }
+  } else {
+    lines.push("No host adapter detected. Generic CLI fallback available.");
+  }
+
+  lines.push("", `Recommended mode: ${readiness.recommendedMode}`);
+  lines.push("Safe to auto-modify: false (approval required before any config change)");
+  lines.push(`Next: ${readiness.nextAction}`);
+
+  if (debug) {
+    lines.push("", "All hosts:");
+    for (const h of readiness.hosts || []) {
+      lines.push(`  [${h.host}] detected=${h.detected} previewAvailable=${h.previewAvailable} configPath=${h.configPath || "none"}`);
+      if (h.reasonCodes && h.reasonCodes.length > 0) {
+        lines.push(`    Reason codes: ${h.reasonCodes.join(", ")}`);
+      }
+    }
+  }
+
+  return lines.join("\n");
+}
+
+module.exports = {
+  CONTRACT,
+  SCHEMA_VERSION,
+  LATEST_READINESS_REL,
+  HOST_CONFIGS,
+  detectAdapterReadiness,
+  buildAdapterReadiness,
+  writeAdapterReadiness,
+  collectAdapterSignals,
+  scoreAdapterReadiness,
+  detectHostCapabilities,
+  classifyHostStatus,
+  buildAdapterReadinessSurface,
+  formatAdapterReadinessText,
+};