meetsoma 0.3.8 → 0.6.0

package/dist/thin-cli.js

@@ -213,6 +213,7 @@ import { join as join3, dirname as dirname3 } from "path";
 import { homedir as homedir3, platform as platform2 } from "os";
 import { fileURLToPath } from "url";
 import { execSync as execSync2, execFileSync } from "child_process";
+import { randomBytes, createHash } from "crypto";
 
 // personality.js
 var _state = {
@@ -1222,7 +1223,7 @@ function showHelp() {
   console.log("");
   console.log(`  ${bold("Maintenance")}`);
   console.log(`    ${green("soma doctor")}            Verify installation + project health`);
-  console.log(`    ${green("soma update")}            Update the Soma runtime`);
+  console.log(`    ${green("soma update")}            Update the Soma runtime ${dim("(--yes / -y to skip prompt)")}`);
   console.log(`    ${green("soma check-updates")}     Check for updates without installing`);
   console.log(`    ${green("soma status")}            Show installation status`);
   console.log("");
@@ -1454,13 +1455,17 @@ async function checkAndUpdate() {
     }
   } catch {
   }
-  const shouldUpdate = await confirmYN(`  ${dim("\u2192")} Update now?`);
+  const autoYes = process.argv.includes("--yes") || process.argv.includes("-y");
+  const shouldUpdate = autoYes ? true : await confirmYN(`  ${dim("\u2192")} Update now?`);
   if (!shouldUpdate) {
     console.log("");
     console.log(`  ${dim("Skipped. Run")} ${green("soma update")} ${dim("anytime to update.")}`);
     console.log("");
     return;
   }
+  if (autoYes) {
+    console.log(`  ${dim("\u2192")} Auto-confirmed via --yes`);
+  }
   console.log("");
   try {
     execSync2("git pull --ff-only", { cwd: installPath, stdio: "ignore" });
@@ -1648,20 +1653,42 @@ async function healthCheck() {
       if (existsSync3(pkgPath)) {
         const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
         const declaredPi = (pkg.dependencies || {})["@mariozechner/pi-coding-agent"];
-        const piPkgPath = join3(CORE_DIR, "node_modules", "@mariozechner", "pi-coding-agent", "package.json");
-        if (existsSync3(piPkgPath)) {
-          const installedPi = JSON.parse(readFileSync3(piPkgPath, "utf-8")).version;
-          const declaredClean = (declaredPi || "").replace(/^[\^~]/, "");
-          if (declaredClean && installedPi && declaredClean !== installedPi) {
-            console.log(`  ${yellow("\u26A0")} Pi runtime drift: declared ${cyan(declaredClean)}, installed ${cyan(installedPi)}`);
-            console.log(`    ${dim("Fix:")} ${green("soma update")}`);
-            warnings++;
-          } else if (installedPi) {
-            console.log(`  ${green("\u2713")} Pi runtime ${installedPi}`);
+        const declaredClean = (declaredPi || "").replace(/^[\^~]/, "");
+        let bundledPi = null;
+        let bundledSource = null;
+        const manifestPath = join3(CORE_DIR, "dist", "manifest.json");
+        if (existsSync3(manifestPath)) {
+          try {
+            const m = JSON.parse(readFileSync3(manifestPath, "utf-8"));
+            if (m.piVersion) {
+              bundledPi = m.piVersion;
+              bundledSource = "dist/manifest.json";
+            }
+          } catch {
           }
-        } else {
-          console.log(`  ${yellow("\u26A0")} Pi not installed \u2014 run ${green("soma update")}`);
+        }
+        let fallbackUsed = false;
+        if (!bundledPi) {
+          const piPkgPath = join3(CORE_DIR, "node_modules", "@mariozechner", "pi-coding-agent", "package.json");
+          if (existsSync3(piPkgPath)) {
+            try {
+              bundledPi = JSON.parse(readFileSync3(piPkgPath, "utf-8")).version;
+              bundledSource = "node_modules (fallback \u2014 dist/manifest.json missing)";
+              fallbackUsed = true;
+            } catch {
+            }
+          }
+        }
+        if (!bundledPi) {
+          console.log(`  ${yellow("\u26A0")} Pi not found \u2014 run ${green("soma update")}`);
+          warnings++;
+        } else if (declaredClean && declaredClean !== bundledPi) {
+          console.log(`  ${yellow("\u26A0")} Pi runtime drift: declared ${cyan(declaredClean)}, bundled ${cyan(bundledPi)}`);
+          console.log(`    ${dim("Fix:")} ${green("soma update")}${fallbackUsed ? dim(" (also rebuild dist: node scripts/build-dist.mjs --clean)") : ""}`);
           warnings++;
+        } else {
+          const suffix = fallbackUsed ? dim(" (via node_modules fallback)") : "";
+          console.log(`  ${green("\u2713")} Pi runtime ${bundledPi}${suffix}`);
         }
       }
     } catch {
@@ -1705,7 +1732,7 @@ async function projectDoctor() {
   }
   printSigma();
   const agentV = getAgentVersion();
-  const projectV = getProjectVersion();
+  let projectV = getProjectVersion();
   const installed = isInstalled();
   console.log(`  ${bold("Soma")} \u2014 Doctor`);
   console.log("");
@@ -1728,11 +1755,190 @@ async function projectDoctor() {
     return;
   }
   if (!projectV) {
-    console.log(`  ${yellow("\u26A0")} Project .soma/ has no version (pre-versioning).`);
-    console.log(`  This project was likely created before v0.6.3.`);
-    console.log(`  Run ${green("/soma doctor")} inside a session to migrate, or re-init with ${green("soma init")}.`);
-    console.log("");
-    return;
+    console.log(`  ${yellow("\u26A0")} Project .soma/ has no version (pre-versioning). Stamping...`);
+    try {
+      const settingsPath = join3(process.cwd(), ".soma", "settings.json");
+      let cfg = {};
+      if (existsSync3(settingsPath)) {
+        try {
+          cfg = JSON.parse(readFileSync3(settingsPath, "utf8"));
+        } catch {
+        }
+      } else {
+        mkdirSync2(dirname3(settingsPath), { recursive: true });
+      }
+      cfg.version = agentV;
+      writeFileSync2(settingsPath, JSON.stringify(cfg, null, 2) + "\n");
+      console.log(`  ${green("\u2713")} Stamped .soma/settings.json \u2192 v${agentV}`);
+      console.log("");
+      projectV = agentV;
+    } catch (e) {
+      console.log(`  ${red("\u2717")} Failed to stamp settings.json: ${e.message}`);
+      console.log(`  Run ${green("soma init")} to scaffold a fresh .soma/settings.json.`);
+      console.log("");
+      return;
+    }
+  }
+  try {
+    const softSomaDir = join3(process.cwd(), ".soma");
+    const softSettings = join3(softSomaDir, "settings.json");
+    if (existsSync3(softSettings)) {
+      const templateRoots = [CORE_DIR, join3(CORE_DIR, "dist")];
+      try {
+        const devCore = readlinkSync2(join3(CORE_DIR, "core"));
+        if (devCore) {
+          const devRoot = dirname3(devCore);
+          templateRoots.push(devRoot, join3(devRoot, "dist"));
+        }
+      } catch {
+      }
+      const phaseDirsSeen = /* @__PURE__ */ new Set();
+      const phaseDirs = [];
+      for (const root of templateRoots) {
+        const d = join3(root, "migrations", "phases");
+        if (existsSync3(d) && !phaseDirsSeen.has(d)) {
+          phaseDirs.push(d);
+          phaseDirsSeen.add(d);
+        }
+      }
+      const seenMaps = /* @__PURE__ */ new Set();
+      const maps = [];
+      for (const dir of phaseDirs) {
+        for (const f of readdirSync(dir).filter((f2) => f2.endsWith(".md"))) {
+          if (seenMaps.has(f)) continue;
+          seenMaps.add(f);
+          maps.push(join3(dir, f));
+        }
+      }
+      let obj = JSON.parse(readFileSync3(softSettings, "utf-8"));
+      let objChanged = false;
+      let replayFixes = 0;
+      for (const mapPath of maps) {
+        let raw;
+        try {
+          raw = readFileSync3(mapPath, "utf-8");
+        } catch {
+          continue;
+        }
+        const fmMatch = raw.match(/^---\n([\s\S]*?)\n---/);
+        if (!fmMatch) continue;
+        const replayLine = fmMatch[1].match(/^replay-until:\s*["']?([^"'\n]+?)["']?\s*$/m);
+        if (!replayLine) continue;
+        const replayUntil = replayLine[1].trim();
+        if (agentV && semverCmp2(agentV, replayUntil) >= 0) continue;
+        const actionsBlock = raw.match(/^## Doctor Actions[\s\S]*?```json\s*\n([\s\S]*?)```/m);
+        if (!actionsBlock) continue;
+        let actions;
+        try {
+          actions = JSON.parse(actionsBlock[1]);
+        } catch {
+          continue;
+        }
+        if (actions["settings-defaults"] && typeof actions["settings-defaults"] === "object") {
+          for (const [k, v] of Object.entries(actions["settings-defaults"])) {
+            if (!(k in obj)) {
+              obj[k] = v;
+              objChanged = true;
+              replayFixes++;
+            }
+          }
+        }
+        if (actions["settings-subkeys"] && typeof actions["settings-subkeys"] === "object") {
+          for (const [parent, sub] of Object.entries(actions["settings-subkeys"])) {
+            if (!obj[parent] || typeof obj[parent] !== "object") continue;
+            for (const [k, v] of Object.entries(sub)) {
+              if (obj[parent][k] === void 0) {
+                obj[parent][k] = v;
+                objChanged = true;
+                replayFixes++;
+              }
+            }
+          }
+        }
+        if (Array.isArray(actions["scaffold-files"])) {
+          for (const entry of actions["scaffold-files"]) {
+            if (!entry || !entry.target || !entry.template) continue;
+            const target = join3(softSomaDir, entry.target);
+            if (existsSync3(target)) continue;
+            for (const root of templateRoots) {
+              const src = join3(root, entry.template);
+              if (!existsSync3(src)) continue;
+              const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+              mkdirSync2(dirname3(target), { recursive: true });
+              writeFileSync2(target, readFileSync3(src, "utf-8").replace(/\{\{today\}\}/g, today));
+              replayFixes++;
+              break;
+            }
+          }
+        }
+      }
+      if (objChanged) writeFileSync2(softSettings, JSON.stringify(obj, null, "	") + "\n");
+      if (replayFixes > 0) {
+        console.log(`  ${green("\u2713")} Migration replay applied ${replayFixes} backfill(s)`);
+        console.log("");
+      }
+    }
+  } catch {
+  }
+  try {
+    const softSomaDir = join3(process.cwd(), ".soma");
+    if (existsSync3(softSomaDir)) {
+      const templateRoots = [CORE_DIR, join3(CORE_DIR, "dist")];
+      try {
+        const devCore = readlinkSync2(join3(CORE_DIR, "core"));
+        if (devCore) {
+          const devRoot = dirname3(devCore);
+          templateRoots.push(devRoot, join3(devRoot, "dist"));
+        }
+      } catch {
+      }
+      let registry = null;
+      let bundledTemplatesDir = null;
+      for (const root of templateRoots) {
+        const regPath = join3(root, "migrations", "template-hashes.json");
+        if (existsSync3(regPath) && !registry) {
+          try {
+            registry = JSON.parse(readFileSync3(regPath, "utf-8"));
+          } catch {
+          }
+        }
+        const td = join3(root, "templates", "default");
+        if (existsSync3(td) && !bundledTemplatesDir) bundledTemplatesDir = td;
+      }
+      if (registry?.templates && bundledTemplatesDir) {
+        const sha256 = (buf) => createHash("sha256").update(buf).digest("hex");
+        let refreshed = 0;
+        let customized = 0;
+        const customizedFiles = [];
+        for (const [filename, meta] of Object.entries(registry.templates)) {
+          const localPath = join3(softSomaDir, "body", filename);
+          const bundledPath = join3(bundledTemplatesDir, filename);
+          if (!existsSync3(localPath) || !existsSync3(bundledPath)) continue;
+          const localContent = readFileSync3(localPath);
+          const bundledContent = readFileSync3(bundledPath);
+          const localHash = sha256(localContent);
+          const bundledHash = sha256(bundledContent);
+          if (localHash === bundledHash) continue;
+          const historical = (meta.historical || []).map((h) => h.sha256);
+          if (historical.includes(localHash)) {
+            writeFileSync2(localPath, bundledContent);
+            console.log(`  ${green("\u2713")} Refreshed body/${filename} (pristine older bundled \u2192 current)`);
+            refreshed++;
+          } else {
+            customized++;
+            customizedFiles.push(filename);
+          }
+        }
+        if (refreshed > 0) console.log("");
+        if (customized > 0) {
+          console.log(`  ${yellow("\u26A0")} Customized body files with bundled updates available: ${customizedFiles.join(", ")}`);
+          console.log(`    ${dim("Review updates: diff body/<file> vs " + bundledTemplatesDir + "/<file>")}`);
+          console.log(`    ${dim("To adopt bundled: rm body/<file> && soma init --force (safe \u2014 writeIfMissing preserves others)")}`);
+          console.log("");
+        }
+      }
+    }
+  } catch {
   }
   if (agentV && semverCmp2(projectV, agentV) === 0) {
     console.log(`  ${green("\u2713")} Project is up to date.`);
@@ -1758,14 +1964,21 @@ async function projectDoctor() {
           }
         };
         add("doctor", { autoUpdate: true, declinedVersion: null });
+        add("keepalive", { maxPings: 5, autoExhale: true, autoExhaleMinTokens: 75e3 });
         add("breathe", { auto: false, triggerAt: 50, rotateAt: 70, graceSeconds: 30 });
         add("context", { notifyAt: 50, warnAt: 70, urgentAt: 80, autoExhaleAt: 85 });
-        add("preload", { staleAfterHours: 48, lastSessionLogs: 0 });
+        add("preload", { staleAfterHours: 48, lastSessionLogs: 0, recentNotesCount: 3 });
         add("scratch", { autoInject: false });
         add("guard", { coreFiles: "warn", bashCommands: "warn", gitIdentity: null });
         add("checkpoints", { enabled: true, intervalMinutes: 5, squashOnPush: true });
+        add("cache", { retention: null });
         add("persona", { name: null, emoji: "\u03C3" });
         add("inherit", { identity: true, protocols: true, muscles: true, tools: true });
+        if (current.preload && typeof current.preload === "object" && current.preload.recentNotesCount === void 0) {
+          current.preload.recentNotesCount = 3;
+          changed = true;
+          fixes++;
+        }
         if (changed) writeFileSync2(settingsPath, JSON.stringify(current, null, "	") + "\n");
       } catch {
       }
@@ -1818,6 +2031,25 @@ async function projectDoctor() {
         }
       }
     }
+    try {
+      const notesTarget = join3(somaDir, "memory", "notes", "soma-log.md");
+      if (!existsSync3(notesTarget)) {
+        const candidates = [
+          join3(agentRoot, "templates", "default", "memory", "notes", "soma-log.md"),
+          join3(agentRoot, "dist", "templates", "default", "memory", "notes", "soma-log.md")
+        ];
+        for (const src of candidates) {
+          if (!existsSync3(src)) continue;
+          const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+          const content = readFileSync3(src, "utf-8").replace(/\{\{today\}\}/g, today);
+          mkdirSync2(dirname3(notesTarget), { recursive: true });
+          writeFileSync2(notesTarget, content);
+          fixes++;
+          break;
+        }
+      }
+    } catch {
+    }
     if (fixes > 0) {
       try {
         const s = JSON.parse(readFileSync3(settingsPath, "utf-8"));
@@ -1976,6 +2208,14 @@ try {
   }
 } catch {
 }
+try {
+  const tokenPath = join3(SOMA_HOME, "somadian-token");
+  if (!existsSync3(tokenPath)) {
+    mkdirSync2(SOMA_HOME, { recursive: true, mode: 448 });
+    writeFileSync2(tokenPath, randomBytes(24).toString("hex"), { mode: 384 });
+  }
+} catch {
+}
 if (cmd === "--version" || cmd === "-v" || cmd === "-V" || cmd === "version") {
   showVersion();
 } else if (cmd === "--help" || cmd === "-h" || cmd === "help") {

package/package.json

@@ -1,44 +1,48 @@
 {
-	"name": "meetsoma",
-	"version": "0.3.8",
-	"description": "Soma — the AI coding agent with self-growing memory",
-	"type": "module",
-	"bin": {
-		"soma": "dist/thin-cli.js"
-	},
-	"files": [
-		"dist/thin-cli.js",
-		"dist/personality.js",
-		"dist/postinstall.js",
-		"LICENSE",
-		"README.md",
-		"CHANGELOG.md"
-	],
-	"keywords": [
-		"soma",
-		"meetsoma",
-		"ai",
-		"agent",
-		"memory",
-		"coding-agent",
-		"identity",
-		"muscles",
-		"protocols",
-		"self-evolving",
-		"cli",
-		"llm"
-	],
-	"author": "Gravicity <hello@gravicity.ai>",
-	"license": "BSL-1.1",
-	"homepage": "https://soma.gravicity.ai",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/meetsoma/soma-agent.git"
-	},
-	"scripts": {
-		"postinstall": "node dist/postinstall.js"
-	},
-	"engines": {
-		"node": ">=20.6.0"
-	}
+  "name": "meetsoma",
+  "version": "0.6.0",
+  "description": "Soma — the AI coding agent with self-growing memory",
+  "type": "module",
+  "bin": {
+    "soma": "dist/thin-cli.js"
+  },
+  "files": [
+    "dist/thin-cli.js",
+    "dist/personality.js",
+    "dist/postinstall.js",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "keywords": [
+    "soma",
+    "meetsoma",
+    "ai",
+    "agent",
+    "memory",
+    "coding-agent",
+    "identity",
+    "muscles",
+    "protocols",
+    "self-evolving",
+    "cli",
+    "llm"
+  ],
+  "author": "Gravicity <hello@gravicity.ai>",
+  "license": "BSL-1.1",
+  "homepage": "https://soma.gravicity.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/meetsoma/soma-agent.git"
+  },
+  "scripts": {
+    "postinstall": "node dist/postinstall.js"
+  },
+  "engines": {
+    "node": ">=20.6.0"
+  },
+  "piConfig": {
+    "name": "soma",
+    "configDir": ".soma"
+  }
 }