@sdotwinter/openclaw-deterministic 0.8.0 → 0.10.0

package/bin/doctor.js

@@ -5,10 +5,16 @@ const path = require("path");
 
 const pkg = require("../package.json");
 
+const args = process.argv.slice(2);
+const JSON_MODE = args.includes("--json");
+
 const HOME = process.env.HOME;
 const openclawRoot = path.join(HOME, ".openclaw");
 const workspace = path.join(openclawRoot, "workspace");
 
+const DEFAULT_HARD_LIMIT = 1200;
+const DEFAULT_RISK_THRESHOLD = 1020;
+
 const files = {
   operating: path.join(workspace, "OPERATING_RULES.md"),
   detSoul: path.join(workspace, "SOUL.deterministic.md"),
@@ -34,27 +40,6 @@ function versionFromFile(content) {
   return match ? match[1] : null;
 }
 
-function checkVersion(filePath, label) {
-  if (!exists(filePath)) {
-    console.log(`❌ ${label} missing.`);
-    return;
-  }
-
-  const content = read(filePath);
-  const version = versionFromFile(content);
-
-  if (!version) {
-    console.log(`⚠ ${label} version stamp missing.`);
-    return;
-  }
-
-  if (version === pkg.version) {
-    console.log(`✅ ${label} version matches CLI (${version})`);
-  } else {
-    console.log(`⚠ ${label} version mismatch (installed ${version}, CLI ${pkg.version})`);
-  }
-}
-
 function overlayEnabled() {
   if (!exists(files.soul)) return false;
   const content = read(files.soul);
@@ -76,43 +61,179 @@ function estimateSemanticTokens() {
   return Math.ceil(content.length / 4);
 }
 
-console.log("\nRunning deterministic doctor...\n");
+function evaluateVersion(filePath) {
+  if (!exists(filePath)) {
+    return { status: "missing", version: null };
+  }
 
-if (!exists(openclawRoot)) {
-  console.log("❌ OpenClaw directory not found.");
-  process.exit(1);
+  const content = read(filePath);
+  const version = versionFromFile(content);
+
+  if (!version) {
+    return { status: "no-stamp", version: null };
+  }
+
+  if (version === pkg.version) {
+    return { status: "match", version };
+  }
+
+  return { status: "mismatch", version };
 }
 
-if (!exists(workspace)) {
-  console.log("❌ Workspace missing.");
-  process.exit(1);
+function parseHardLimit() {
+  if (!exists(files.compactor)) return null;
+
+  const content = read(files.compactor);
+
+  const match = content.match(/HARD_LIMIT[^0-9]*([0-9]+)/);
+  if (!match) return null;
+
+  return parseInt(match[1], 10);
 }
 
-checkVersion(files.operating, "OPERATING_RULES.md");
-checkVersion(files.detSoul, "SOUL.deterministic.md");
-checkVersion(files.compactor, "memory-compactor SKILL.md");
+function parseRiskThreshold() {
+  if (!exists(files.compactor)) return null;
+
+  const content = read(files.compactor);
+
+  const match = content.match(/RISK_THRESHOLD[^0-9]*([0-9]+)/);
+  if (!match) return null;
+
+  return parseInt(match[1], 10);
+}
+
+function evaluate() {
+  const result = {
+    cliVersion: pkg.version,
+    openclawDetected: exists(openclawRoot),
+    workspaceDetected: exists(workspace),
+    files: {},
+    overlayEnabled: false,
+    semanticTokens: 0,
+    semanticStatus: "safe",
+    limits: {
+      hardLimitConfigured: null,
+      riskThresholdConfigured: null,
+      hardLimitDefault: DEFAULT_HARD_LIMIT,
+      riskThresholdDefault: DEFAULT_RISK_THRESHOLD,
+      coherent: true,
+    },
+  };
+
+  if (!result.openclawDetected || !result.workspaceDetected) {
+    return result;
+  }
+
+  result.files.operating = evaluateVersion(files.operating);
+  result.files.detSoul = evaluateVersion(files.detSoul);
+  result.files.compactor = evaluateVersion(files.compactor);
+
+  result.overlayEnabled = overlayEnabled();
+
+  const tokens = estimateSemanticTokens();
+  result.semanticTokens = tokens;
+
+  const hardLimit = parseHardLimit();
+  const riskThreshold = parseRiskThreshold();
+
+  result.limits.hardLimitConfigured = hardLimit;
+  result.limits.riskThresholdConfigured = riskThreshold;
+
+  if (hardLimit && hardLimit !== DEFAULT_HARD_LIMIT) {
+    result.limits.coherent = false;
+  }
+
+  if (riskThreshold && riskThreshold !== DEFAULT_RISK_THRESHOLD) {
+    result.limits.coherent = false;
+  }
+
+  const effectiveHardLimit = hardLimit || DEFAULT_HARD_LIMIT;
+  const effectiveRiskThreshold = riskThreshold || DEFAULT_RISK_THRESHOLD;
+
+  if (tokens > effectiveHardLimit) {
+    result.semanticStatus = "hard-limit-exceeded";
+  } else if (tokens > effectiveRiskThreshold) {
+    result.semanticStatus = "risk-threshold";
+  } else {
+    result.semanticStatus = "safe";
+  }
+
+  return result;
+}
+
+function printHuman(result) {
+  console.log("\nRunning deterministic doctor...\n");
+
+  if (!result.openclawDetected) {
+    console.log("❌ OpenClaw directory not found.");
+    process.exit(1);
+  }
+
+  if (!result.workspaceDetected) {
+    console.log("❌ Workspace missing.");
+    process.exit(1);
+  }
+
+  for (const [name, info] of Object.entries(result.files)) {
+    const label =
+      name === "operating"
+        ? "OPERATING_RULES.md"
+        : name === "detSoul"
+        ? "SOUL.deterministic.md"
+        : "memory-compactor SKILL.md";
+
+    if (info.status === "missing") {
+      console.log(`❌ ${label} missing.`);
+    } else if (info.status === "no-stamp") {
+      console.log(`⚠ ${label} version stamp missing.`);
+    } else if (info.status === "mismatch") {
+      console.log(
+        `⚠ ${label} version mismatch (installed ${info.version}, CLI ${pkg.version})`
+      );
+    } else {
+      console.log(`✅ ${label} version matches CLI (${info.version})`);
+    }
+  }
 
-if (exists(files.soul)) {
   console.log("✅ SOUL.md present.");
-  if (overlayEnabled()) {
-    console.log("✅ Deterministic overlay ENABLED in SOUL.md.");
+  console.log(
+    result.overlayEnabled
+      ? "✅ Deterministic overlay ENABLED in SOUL.md."
+      : "⚠ Deterministic overlay NOT enabled in SOUL.md."
+  );
+
+  if (!result.limits.coherent) {
+    console.log("⚠ Threshold configuration drift detected in SKILL.md.");
+  }
+
+  console.log(`\nSemantic memory tokens (est): ${result.semanticTokens}`);
+
+  if (result.semanticStatus === "hard-limit-exceeded") {
+    console.log("❌ Semantic memory exceeds HARD_LIMIT.");
+  } else if (result.semanticStatus === "risk-threshold") {
+    console.log("⚠ Semantic memory above risk threshold.");
   } else {
-    console.log("⚠ Deterministic overlay NOT enabled in SOUL.md.");
+    console.log("✅ Semantic memory within safe bounds.");
   }
-} else {
-  console.log("⚠ SOUL.md not found.");
+
+  console.log("\nDoctor complete.\n");
 }
 
-const semanticTokens = estimateSemanticTokens();
-console.log(`\nSemantic memory tokens (est): ${semanticTokens}`);
+const result = evaluate();
+
+if (JSON_MODE) {
+  console.log(JSON.stringify(result, null, 2));
+
+  if (!result.openclawDetected || !result.workspaceDetected) {
+    process.exit(2);
+  }
+
+  if (result.semanticStatus === "hard-limit-exceeded") {
+    process.exit(3);
+  }
 
-if (semanticTokens > 1200) {
-  console.log("❌ Semantic memory exceeds HARD_LIMIT (1200).");
-} else if (semanticTokens > 1020) {
-  console.log("⚠ Semantic memory above risk threshold (1020).");
-} else {
-  console.log("✅ Semantic memory within safe bounds.");
+  process.exit(0);
 }
 
-console.log("\nDoctor complete.\n");
+printHuman(result);
 process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdotwinter/openclaw-deterministic",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Deterministic governance and memory compaction layer for OpenClaw",
   "keywords": [
     "openclaw",