@sdotwinter/openclaw-deterministic 0.1.2 → 0.1.3

package/bin/doctor.js

@@ -1,46 +1,59 @@
 #!/usr/bin/env node
 
 const fs = require("fs");
-const os = require("os");
 const path = require("path");
+const os = require("os");
 
-const HOME = os.homedir();
-const OPENCLAW_DIR = path.join(HOME, ".openclaw");
+const pkg = require("../package.json");
+
+const OPENCLAW_DIR = path.join(os.homedir(), ".openclaw");
 const WORKSPACE_DIR = path.join(OPENCLAW_DIR, "workspace");
 
-console.log("Running deterministic doctor...\n");
+function checkFile(filePath, label) {
+  if (!fs.existsSync(filePath)) {
+    console.log(`❌ Missing: ${label}`);
+    return;
+  }
 
-if (!fs.existsSync(OPENCLAW_DIR)) {
-  console.log("❌ ~/.openclaw not found.");
-  process.exit(1);
-}
+  const content = fs.readFileSync(filePath, "utf8");
 
-if (!fs.existsSync(WORKSPACE_DIR)) {
-  console.log("❌ workspace not found.");
-  process.exit(1);
+  if (!content.includes("Installed by openclaw-deterministic")) {
+    console.log(`⚠️  ${label} exists but is not deterministic-managed.`);
+    return;
+  }
+
+  if (!content.includes(`v${pkg.version}`)) {
+    console.log(`⚠️  ${label} version drift detected.`);
+    return;
+  }
+
+  console.log(`✅ ${label} OK (v${pkg.version})`);
 }
 
-console.log("✅ OpenClaw directory detected.");
-console.log("✅ Workspace detected.");
+function runDoctor() {
+  console.log("Running deterministic doctor...\n");
 
-const hasOperating = fs.existsSync(
-  path.join(WORKSPACE_DIR, "OPERATING_RULES.md")
-);
+  if (!fs.existsSync(OPENCLAW_DIR)) {
+    console.log("❌ OpenClaw not installed.");
+    process.exit(1);
+  }
 
-const hasSkill = fs.existsSync(
-  path.join(WORKSPACE_DIR, "skills", "memory-compactor", "SKILL.md")
-);
+  checkFile(
+    path.join(WORKSPACE_DIR, "OPERATING_RULES.md"),
+    "OPERATING_RULES.md"
+  );
 
-console.log(
-  hasOperating
-    ? "✅ OPERATING_RULES.md present."
-    : "⚠️ OPERATING_RULES.md missing."
-);
+  checkFile(
+    path.join(WORKSPACE_DIR, "SOUL.deterministic.md"),
+    "SOUL.deterministic.md"
+  );
 
-console.log(
-  hasSkill
-    ? "✅ memory-compactor skill present."
-    : "⚠️ memory-compactor skill missing."
-);
+  checkFile(
+    path.join(WORKSPACE_DIR, "skills", "memory-compactor", "SKILL.md"),
+    "memory-compactor SKILL.md"
+  );
+
+  console.log("\nDoctor complete.");
+}
 
-console.log("\nDoctor complete.");
+runDoctor();

package/bin/install.js

@@ -4,95 +4,100 @@ const fs = require("fs");
 const path = require("path");
 const os = require("os");
 
-const HOME = os.homedir();
-const OPENCLAW_DIR = path.join(HOME, ".openclaw");
-const WORKSPACE_DIR = path.join(OPENCLAW_DIR, "workspace");
-const TEMPLATE_DIR = path.join(__dirname, "..", "templates");
-
-function log(msg) {
-  console.log(msg);
-}
+const pkg = require("../package.json");
 
-function exitWith(msg) {
-  console.error(msg);
-  process.exit(1);
-}
+const OPENCLAW_DIR = path.join(os.homedir(), ".openclaw");
+const WORKSPACE_DIR = path.join(OPENCLAW_DIR, "workspace");
+const BACKUP_ROOT = path.join(OPENCLAW_DIR, "backups", "deterministic");
 
-function exists(p) {
-  return fs.existsSync(p);
-}
+const TEMPLATES_DIR = path.join(__dirname, "..", "templates");
 
-function ensureDir(p) {
-  if (!exists(p)) {
-    fs.mkdirSync(p, { recursive: true });
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
   }
 }
 
-function copyFileSafe(src, dest) {
-  if (!exists(dest)) {
-    fs.copyFileSync(src, dest);
-    log(`✅ Installed: ${path.basename(dest)}`);
-  } else {
-    log(`⚠️  Skipped (already exists): ${path.basename(dest)}`);
-  }
+function timestamp() {
+  return new Date().toISOString().replace(/:/g, "-");
 }
 
-function backupFile(filePath, backupDir) {
-  if (!exists(filePath)) return;
-
-  const filename = path.basename(filePath);
-  const dest = path.join(backupDir, filename);
-  fs.copyFileSync(filePath, dest);
-  log(`🗂️  Backed up: ${filename}`);
-}
+function addHeader(content) {
+  const header =
+`# Installed by openclaw-deterministic v${pkg.version}
+# Installed at: ${new Date().toISOString()}
 
-function timestamp() {
-  const now = new Date();
-  return now.toISOString().replace(/[:.]/g, "-");
+`;
+  return header + content;
 }
 
-function validateWorkspace() {
-  if (!exists(OPENCLAW_DIR)) {
-    exitWith("❌ OpenClaw not detected.\nExpected directory: " + OPENCLAW_DIR);
-  }
-
-  if (!exists(WORKSPACE_DIR)) {
-    exitWith("❌ OpenClaw workspace not detected.\nExpected directory: " + WORKSPACE_DIR);
+function backupFile(filePath, backupDir) {
+  if (fs.existsSync(filePath)) {
+    const fileName = path.basename(filePath);
+    fs.copyFileSync(filePath, path.join(backupDir, fileName));
   }
 }
 
-function runInstall() {
-  log("Running deterministic install phase...\n");
-
-  validateWorkspace();
+function installFile(templateName, targetPath, backupDir) {
+  const templatePath = path.join(TEMPLATES_DIR, templateName);
 
-  const backupDir = path.join(WORKSPACE_DIR, "_backup", timestamp());
-  ensureDir(backupDir);
+  if (!fs.existsSync(templatePath)) {
+    console.error(`Template not found: ${templateName}`);
+    process.exit(1);
+  }
 
-  // Backup important files if they exist
-  backupFile(path.join(WORKSPACE_DIR, "OPERATING_RULES.md"), backupDir);
-  backupFile(path.join(WORKSPACE_DIR, "SOUL.md"), backupDir);
+  backupFile(targetPath, backupDir);
 
-  log("\n--- Installing Governance Files ---");
+  const templateContent = fs.readFileSync(templatePath, "utf8");
+  const stampedContent = addHeader(templateContent);
 
-  // Install OPERATING_RULES.md (only if missing)
-  const operatingSrc = path.join(TEMPLATE_DIR, "OPERATING_RULES.md");
-  const operatingDest = path.join(WORKSPACE_DIR, "OPERATING_RULES.md");
-  copyFileSafe(operatingSrc, operatingDest);
+  fs.writeFileSync(targetPath, stampedContent, "utf8");
 
-  log("\n--- Installing Memory Compactor Skill ---");
+  console.log(`Installed: ${targetPath}`);
+}
 
-  const skillDir = path.join(WORKSPACE_DIR, "skills", "memory-compactor");
-  ensureDir(skillDir);
+function runInstall() {
+  if (!fs.existsSync(OPENCLAW_DIR)) {
+    console.error("OpenClaw directory not found.");
+    console.error("Install OpenClaw first: npm i -g openclaw && openclaw onboard");
+    process.exit(1);
+  }
 
-  const skillSrc = path.join(TEMPLATE_DIR, "memory-compactor.SKILL.md");
-  const skillDest = path.join(skillDir, "SKILL.md");
-  copyFileSafe(skillSrc, skillDest);
+  ensureDir(WORKSPACE_DIR);
+  ensureDir(BACKUP_ROOT);
 
-  log("\n--- SOUL Installation Deferred ---");
-  log("⚠️  SOUL.md not modified (manual merge required)");
+  const backupDir = path.join(BACKUP_ROOT, timestamp());
+  ensureDir(backupDir);
 
-  log("\n✅ Deterministic install complete.");
+  console.log("Creating deterministic backup snapshot...");
+  console.log(`Backup location: ${backupDir}`);
+
+  // Install OPERATING_RULES.md
+  installFile(
+    "OPERATING_RULES.md",
+    path.join(WORKSPACE_DIR, "OPERATING_RULES.md"),
+    backupDir
+  );
+
+  // Install deterministic SOUL overlay
+  installFile(
+    "SOUL.deterministic.md",
+    path.join(WORKSPACE_DIR, "SOUL.deterministic.md"),
+    backupDir
+  );
+
+  // Install memory-compactor skill
+  const skillsDir = path.join(WORKSPACE_DIR, "skills", "memory-compactor");
+  ensureDir(skillsDir);
+
+  installFile(
+    "memory-compactor.SKILL.md",
+    path.join(skillsDir, "SKILL.md"),
+    backupDir
+  );
+
+  console.log("\nDeterministic governance installed successfully.");
+  console.log("User SOUL.md was NOT modified.");
 }
 
 runInstall();

package/bin/revert.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const OPENCLAW_DIR = path.join(os.homedir(), ".openclaw");
+const WORKSPACE_DIR = path.join(OPENCLAW_DIR, "workspace");
+const BACKUP_ROOT = path.join(OPENCLAW_DIR, "backups", "deterministic");
+
+const args = process.argv.slice(2);
+
+function listBackups() {
+  if (!fs.existsSync(BACKUP_ROOT)) {
+    console.log("No backups found.");
+    return;
+  }
+
+  const dirs = fs.readdirSync(BACKUP_ROOT);
+  if (dirs.length === 0) {
+    console.log("No backups found.");
+    return;
+  }
+
+  console.log("Available backups:");
+  dirs.forEach(d => console.log(`- ${d}`));
+}
+
+function restoreBackup(timestamp) {
+  const backupDir = path.join(BACKUP_ROOT, timestamp);
+
+  if (!fs.existsSync(backupDir)) {
+    console.log("Backup not found.");
+    process.exit(1);
+  }
+
+  const files = fs.readdirSync(backupDir);
+
+  files.forEach(file => {
+    const src = path.join(backupDir, file);
+    const dest = path.join(WORKSPACE_DIR, file);
+
+    fs.copyFileSync(src, dest);
+    console.log(`Restored: ${file}`);
+  });
+
+  console.log("Revert complete.");
+}
+
+if (args[0] === "--list") {
+  listBackups();
+} else if (args[0] === "--to" && args[1]) {
+  restoreBackup(args[1]);
+} else {
+  console.log("Usage:");
+  console.log("  oc-deterministic revert --list");
+  console.log("  oc-deterministic revert --to <timestamp>");
+}

package/package.json

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