@aman_asmuei/aman 0.5.2 → 0.5.4

package/dist/index.js

@@ -4,9 +4,9 @@ import { Command } from "commander";
 // src/commands/setup.ts
 import * as p from "@clack/prompts";
 import pc from "picocolors";
-import fs4 from "fs";
-import path3 from "path";
-import os2 from "os";
+import fs5 from "fs";
+import path4 from "path";
+import os3 from "os";
 
 // src/lib/detect.ts
 import fs from "fs";
@@ -266,6 +266,75 @@ function getPlatformFile(platform) {
   }
 }
 
+// src/lib/heal.ts
+import fs4 from "fs";
+import path3 from "path";
+import os2 from "os";
+var TEMPLATE_MARKERS = /\[your name\]|\[YOUR_NAME\]|\[AI_NAME\]/;
+function healLayerScope(layerDir, filename, home) {
+  const homeDir = home ?? os2.homedir();
+  const scopedPath = path3.join(homeDir, layerDir, "dev", "plugin", filename);
+  const legacyPath = path3.join(homeDir, layerDir, filename);
+  const scopedExists = fs4.existsSync(scopedPath);
+  const legacyExists = fs4.existsSync(legacyPath);
+  if (!legacyExists) {
+    return scopedExists ? "ok" : "no-op";
+  }
+  const legacyContent = fs4.readFileSync(legacyPath, "utf-8");
+  if (TEMPLATE_MARKERS.test(legacyContent)) {
+    return "no-op";
+  }
+  if (!scopedExists) {
+    fs4.mkdirSync(path3.dirname(scopedPath), { recursive: true });
+    fs4.writeFileSync(scopedPath, legacyContent, "utf-8");
+    return "migrated";
+  }
+  const scopedContent = fs4.readFileSync(scopedPath, "utf-8");
+  if (TEMPLATE_MARKERS.test(scopedContent)) {
+    fs4.writeFileSync(scopedPath, legacyContent, "utf-8");
+    return "repaired";
+  }
+  if (scopedContent === legacyContent) {
+    return "ok";
+  }
+  const legacyMtime = fs4.statSync(legacyPath).mtimeMs;
+  const scopedMtime = fs4.statSync(scopedPath).mtimeMs;
+  if (legacyMtime > scopedMtime) {
+    fs4.writeFileSync(scopedPath, legacyContent, "utf-8");
+    return "synced";
+  }
+  if (scopedMtime > legacyMtime) {
+    fs4.writeFileSync(legacyPath, scopedContent, "utf-8");
+    return "synced";
+  }
+  fs4.writeFileSync(legacyPath, scopedContent, "utf-8");
+  return "synced";
+}
+function healResultMessage(layerDir, filename, result) {
+  if (result === "migrated") {
+    return `${layerDir.replace(/^\./, "")}: migrated ~/${layerDir}/${filename} \u2192 ~/${layerDir}/dev/plugin/${filename}`;
+  }
+  if (result === "repaired") {
+    return `${layerDir.replace(/^\./, "")}: replaced unfilled template at ~/${layerDir}/dev/plugin/${filename} with your personalised content`;
+  }
+  if (result === "synced") {
+    return `${layerDir.replace(/^\./, "")}: synced diverged content between ~/${layerDir}/${filename} and ~/${layerDir}/dev/plugin/${filename} (newer wins)`;
+  }
+  return null;
+}
+function runAutoHeal(home) {
+  const messages = [];
+  for (const [layerDir, filename] of [
+    [".acore", "core.md"],
+    [".arules", "rules.md"]
+  ]) {
+    const result = healLayerScope(layerDir, filename, home);
+    const msg = healResultMessage(layerDir, filename, result);
+    if (msg) messages.push(msg);
+  }
+  return messages;
+}
+
 // src/templates.ts
 var STARTER_FLOW = `# My Workflows
 
@@ -383,40 +452,12 @@ var ARCHETYPES = {
 };
 async function setupCommand() {
   p.intro(pc.bold("aman") + " \u2014 your complete AI companion");
+  for (const msg of runAutoHeal()) {
+    p.log.success(msg);
+  }
   const ecosystem = detectEcosystem();
-  const scopedCorePath = path3.join(os2.homedir(), ".acore", "dev", "plugin", "core.md");
-  const legacyCorePath = path3.join(os2.homedir(), ".acore", "core.md");
   if (ecosystem.acore.installed) {
-    const scopedExists = fs4.existsSync(scopedCorePath);
-    const legacyExists = fs4.existsSync(legacyCorePath);
-    if (legacyExists) {
-      const legacyContent = fs4.readFileSync(legacyCorePath, "utf-8");
-      const legacyIsTemplate = /\[your name\]|\[YOUR_NAME\]|\[AI_NAME\]/.test(legacyContent);
-      if (!legacyIsTemplate) {
-        if (!scopedExists) {
-          fs4.mkdirSync(path3.dirname(scopedCorePath), { recursive: true });
-          fs4.writeFileSync(scopedCorePath, legacyContent, "utf-8");
-          p.log.success(
-            `Identity: migrated ${pc.dim("~/.acore/core.md")} \u2192 ${pc.dim("~/.acore/dev/plugin/core.md")}`
-          );
-        } else {
-          const scopedContent = fs4.readFileSync(scopedCorePath, "utf-8");
-          const scopedIsTemplate = /\[your name\]|\[YOUR_NAME\]|\[AI_NAME\]/.test(scopedContent);
-          if (scopedIsTemplate) {
-            fs4.writeFileSync(scopedCorePath, legacyContent, "utf-8");
-            p.log.success(
-              `Identity: replaced unfilled template at ${pc.dim("~/.acore/dev/plugin/core.md")} with your personalized identity`
-            );
-          } else {
-            p.log.success(`Identity: ${pc.dim(ecosystem.acore.path)} already exists`);
-          }
-        }
-      } else {
-        p.log.success(`Identity: ${pc.dim(ecosystem.acore.path)} already exists`);
-      }
-    } else {
-      p.log.success(`Identity: ${pc.dim(ecosystem.acore.path)} already exists`);
-    }
+    p.log.success(`Identity: ${pc.dim(ecosystem.acore.path)} already exists`);
   } else {
     p.log.step("Setting up your AI identity...");
     let userName = detectUserName();
@@ -462,13 +503,13 @@ async function setupCommand() {
       DATE: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
       UPDATE_INSTRUCTIONS: getUpdateInstructions(platform)
     });
-    const scopedAcoreDir = path3.join(os2.homedir(), ".acore", "dev", "plugin");
-    fs4.mkdirSync(scopedAcoreDir, { recursive: true });
-    fs4.writeFileSync(path3.join(scopedAcoreDir, "core.md"), content, "utf-8");
+    const scopedAcoreDir = path4.join(os3.homedir(), ".acore", "dev", "plugin");
+    fs5.mkdirSync(scopedAcoreDir, { recursive: true });
+    fs5.writeFileSync(path4.join(scopedAcoreDir, "core.md"), content, "utf-8");
     p.log.success(`Created ${pc.dim("~/.acore/dev/plugin/core.md")} (identity)`);
     if (stack) {
-      const localDir = path3.join(process.cwd(), ".acore");
-      fs4.mkdirSync(localDir, { recursive: true });
+      const localDir = path4.join(process.cwd(), ".acore");
+      fs5.mkdirSync(localDir, { recursive: true });
       const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
       const contextContent = `## Work
 - Stack: ${stack}
@@ -485,9 +526,9 @@ async function setupCommand() {
 ## Project Patterns
 - [observations specific to this project \u2014 built over time]
 `;
-      fs4.writeFileSync(path3.join(localDir, "context.md"), contextContent, "utf-8");
+      fs5.writeFileSync(path4.join(localDir, "context.md"), contextContent, "utf-8");
       const configContent = JSON.stringify({ platform: platform || "other" }, null, 2) + "\n";
-      fs4.writeFileSync(path3.join(localDir, "config.json"), configContent, "utf-8");
+      fs5.writeFileSync(path4.join(localDir, "config.json"), configContent, "utf-8");
     } else {
       p.log.info(
         `No project detected here \u2014 run ${pc.bold("aman here")} later from inside any repo to add per-project context.`
@@ -495,7 +536,7 @@ async function setupCommand() {
     }
     const platformFile = getPlatformFile(platform);
     if (platformFile) {
-      const filePath = path3.join(process.cwd(), platformFile);
+      const filePath = path4.join(process.cwd(), platformFile);
       const result = injectIntoFile(filePath, content);
       if (result.created) {
         p.log.success(`Created ${pc.dim(platformFile)} with identity`);
@@ -507,7 +548,7 @@ async function setupCommand() {
     if (stack) inferredParts.push(stack);
     p.log.info(`Inferred: ${pc.dim(inferredParts.join(" \xB7 "))}`);
   }
-  const home = os2.homedir();
+  const home = os3.homedir();
   const aflowExists = ecosystem.aflow.installed;
   const arulesExists = ecosystem.arules.installed;
   const aevalExists = ecosystem.aeval.installed;
@@ -550,26 +591,26 @@ async function setupCommand() {
       doEval = selected.includes("eval");
     }
     if (doFlow) {
-      const aflowDir = path3.join(home, ".aflow");
-      fs4.mkdirSync(aflowDir, { recursive: true });
-      fs4.writeFileSync(path3.join(aflowDir, "flow.md"), STARTER_FLOW, "utf-8");
+      const aflowDir = path4.join(home, ".aflow");
+      fs5.mkdirSync(aflowDir, { recursive: true });
+      fs5.writeFileSync(path4.join(aflowDir, "flow.md"), STARTER_FLOW, "utf-8");
       p.log.success(`Workflows: created ${pc.dim("~/.aflow/flow.md")} (4 starter workflows)`);
     } else if (aflowExists) {
       p.log.success(`Workflows: ${ecosystem.aflow.workflowCount} defined`);
     }
     if (doRules) {
-      const arulesDir = path3.join(home, ".arules", "dev", "plugin");
-      fs4.mkdirSync(arulesDir, { recursive: true });
-      fs4.writeFileSync(path3.join(arulesDir, "rules.md"), STARTER_RULES, "utf-8");
+      const arulesDir = path4.join(home, ".arules", "dev", "plugin");
+      fs5.mkdirSync(arulesDir, { recursive: true });
+      fs5.writeFileSync(path4.join(arulesDir, "rules.md"), STARTER_RULES, "utf-8");
       p.log.success(`Guardrails: created ${pc.dim("~/.arules/dev/plugin/rules.md")} (24 rules)`);
     } else if (arulesExists) {
       p.log.success(`Guardrails: ${ecosystem.arules.ruleCount} rules`);
     }
     if (doEval) {
-      const aevalDir = path3.join(home, ".aeval");
-      fs4.mkdirSync(aevalDir, { recursive: true });
+      const aevalDir = path4.join(home, ".aeval");
+      fs5.mkdirSync(aevalDir, { recursive: true });
       const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-      fs4.writeFileSync(path3.join(aevalDir, "eval.md"), STARTER_EVAL.replace("{{DATE}}", today), "utf-8");
+      fs5.writeFileSync(path4.join(aevalDir, "eval.md"), STARTER_EVAL.replace("{{DATE}}", today), "utf-8");
       p.log.success(`Evaluation: created ${pc.dim("~/.aeval/eval.md")}`);
     } else if (aevalExists) {
       p.log.success("Evaluation: already configured");
@@ -603,13 +644,13 @@ async function setupCommand() {
 // src/commands/status.ts
 import * as p2 from "@clack/prompts";
 import pc2 from "picocolors";
-import fs5 from "fs";
+import fs6 from "fs";
 function statusCommand() {
   p2.intro(pc2.bold("aman") + " \u2014 ecosystem status");
   const ecosystem = detectEcosystem();
   const platform = detectPlatform();
   if (ecosystem.acore.installed) {
-    const content = fs5.readFileSync(ecosystem.acore.path, "utf-8");
+    const content = fs6.readFileSync(ecosystem.acore.path, "utf-8");
     const aiName = content.match(/^# (.+)$/m)?.[1] || "Companion";
     const userName = content.match(/- Name: (.+)$/m)?.[1] || "Unknown";
     p2.log.success(`Identity: ${pc2.bold(aiName)} + ${pc2.bold(userName)}`);
@@ -674,8 +715,8 @@ function statusCommand() {
 }
 
 // src/commands/deploy.ts
-import fs6 from "fs";
-import path4 from "path";
+import fs7 from "fs";
+import path5 from "path";
 import * as p3 from "@clack/prompts";
 import pc3 from "picocolors";
 async function deployCommand() {
@@ -732,15 +773,15 @@ AMAN_MODEL=${isAnthropic ? "claude-sonnet-4-6" : "gpt-4o"}
 # TELEGRAM_BOT_TOKEN=
 # DISCORD_BOT_TOKEN=
 `;
-  const envPath = path4.join(cwd, ".env");
-  fs6.writeFileSync(envPath, envContent, "utf-8");
+  const envPath = path5.join(cwd, ".env");
+  fs7.writeFileSync(envPath, envContent, "utf-8");
   p3.log.success(`Created ${pc3.bold(".env")} with API key`);
   const pkgDir = findPackageDir();
   copyDeployFile(pkgDir, cwd, "Dockerfile");
   copyDeployFile(pkgDir, cwd, "docker-entrypoint.sh");
   copyDeployFile(pkgDir, cwd, "docker-compose.yml");
   try {
-    fs6.chmodSync(path4.join(cwd, "docker-entrypoint.sh"), 493);
+    fs7.chmodSync(path5.join(cwd, "docker-entrypoint.sh"), 493);
   } catch {
   }
   p3.log.success(`Created ${pc3.bold("Dockerfile")} + ${pc3.bold("docker-compose.yml")}`);
@@ -776,20 +817,20 @@ AMAN_MODEL=${model}
 # TELEGRAM_BOT_TOKEN=
 # DISCORD_BOT_TOKEN=
 `;
-  const envPath = path4.join(cwd, ".env");
-  fs6.writeFileSync(envPath, envContent, "utf-8");
+  const envPath = path5.join(cwd, ".env");
+  fs7.writeFileSync(envPath, envContent, "utf-8");
   p3.log.success(`Created ${pc3.bold(".env")} with Ollama config`);
   const pkgDir = findPackageDir();
   copyDeployFile(pkgDir, cwd, "Dockerfile");
   copyDeployFile(pkgDir, cwd, "docker-entrypoint.sh");
   copyDeployFile(pkgDir, cwd, "docker-compose.ollama.yml");
-  const src = path4.join(cwd, "docker-compose.ollama.yml");
-  const dest = path4.join(cwd, "docker-compose.yml");
-  if (fs6.existsSync(src) && !fs6.existsSync(dest)) {
-    fs6.renameSync(src, dest);
+  const src = path5.join(cwd, "docker-compose.ollama.yml");
+  const dest = path5.join(cwd, "docker-compose.yml");
+  if (fs7.existsSync(src) && !fs7.existsSync(dest)) {
+    fs7.renameSync(src, dest);
   }
   try {
-    fs6.chmodSync(path4.join(cwd, "docker-entrypoint.sh"), 493);
+    fs7.chmodSync(path5.join(cwd, "docker-entrypoint.sh"), 493);
   } catch {
   }
   p3.log.success(`Created ${pc3.bold("Dockerfile")} + ${pc3.bold("docker-compose.yml")} (with Ollama)`);
@@ -866,18 +907,18 @@ ${pc3.bold("Raspberry Pi:")}
 function findPackageDir() {
   let dir = new URL(".", import.meta.url).pathname;
   for (let i = 0; i < 5; i++) {
-    if (fs6.existsSync(path4.join(dir, "Dockerfile"))) return dir;
-    dir = path4.dirname(dir);
+    if (fs7.existsSync(path5.join(dir, "Dockerfile"))) return dir;
+    dir = path5.dirname(dir);
   }
-  const globalDir = path4.join(process.env.npm_config_prefix || "/usr/local", "lib/node_modules/@aman_asmuei/aman");
-  if (fs6.existsSync(path4.join(globalDir, "Dockerfile"))) return globalDir;
+  const globalDir = path5.join(process.env.npm_config_prefix || "/usr/local", "lib/node_modules/@aman_asmuei/aman");
+  if (fs7.existsSync(path5.join(globalDir, "Dockerfile"))) return globalDir;
   return process.cwd();
 }
 function copyDeployFile(pkgDir, destDir, filename) {
-  const src = path4.join(pkgDir, filename);
-  const dest = path4.join(destDir, filename);
-  if (fs6.existsSync(src)) {
-    fs6.copyFileSync(src, dest);
+  const src = path5.join(pkgDir, filename);
+  const dest = path5.join(destDir, filename);
+  if (fs7.existsSync(src)) {
+    fs7.copyFileSync(src, dest);
   }
 }
 
@@ -1007,14 +1048,14 @@ async function showcaseCommand(nameArg, opts = {}) {
 // src/commands/here.ts
 import * as p5 from "@clack/prompts";
 import pc5 from "picocolors";
-import fs7 from "fs";
-import path5 from "path";
+import fs8 from "fs";
+import path6 from "path";
 async function hereCommand(opts = {}) {
   const cwd = process.cwd();
-  const acoreDir = path5.join(cwd, ".acore");
-  const contextPath = path5.join(acoreDir, "context.md");
-  const configPath = path5.join(acoreDir, "config.json");
-  if (fs7.existsSync(contextPath) && !opts.force) {
+  const acoreDir = path6.join(cwd, ".acore");
+  const contextPath = path6.join(acoreDir, "context.md");
+  const configPath = path6.join(acoreDir, "config.json");
+  if (fs8.existsSync(contextPath) && !opts.force) {
     p5.intro(pc5.bold("aman here") + " \u2014 project context card");
     const overwrite = await p5.confirm({
       message: `${pc5.dim(".acore/context.md")} already exists. Overwrite?`,
@@ -1028,7 +1069,7 @@ async function hereCommand(opts = {}) {
   const stack = detectStack() || "unknown";
   const platform = detectPlatform();
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  fs7.mkdirSync(acoreDir, { recursive: true });
+  fs8.mkdirSync(acoreDir, { recursive: true });
   const contextContent = `## Work
 - Stack: ${stack}
 - Domain:
@@ -1044,21 +1085,21 @@ async function hereCommand(opts = {}) {
 ## Project Patterns
 - [observations specific to this project \u2014 built over time]
 `;
-  fs7.writeFileSync(contextPath, contextContent, "utf-8");
-  if (fs7.existsSync(configPath)) {
+  fs8.writeFileSync(contextPath, contextContent, "utf-8");
+  if (fs8.existsSync(configPath)) {
     try {
-      const existing = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+      const existing = JSON.parse(fs8.readFileSync(configPath, "utf-8"));
       if (typeof existing.platform !== "string" || existing.platform === "") {
         existing.platform = platform || "other";
-        fs7.writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+        fs8.writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
       }
     } catch {
       const fresh = { platform: platform || "other" };
-      fs7.writeFileSync(configPath, JSON.stringify(fresh, null, 2) + "\n", "utf-8");
+      fs8.writeFileSync(configPath, JSON.stringify(fresh, null, 2) + "\n", "utf-8");
     }
   } else {
     const fresh = { platform: platform || "other" };
-    fs7.writeFileSync(configPath, JSON.stringify(fresh, null, 2) + "\n", "utf-8");
+    fs8.writeFileSync(configPath, JSON.stringify(fresh, null, 2) + "\n", "utf-8");
   }
   if (opts.force) {
     return;
@@ -1071,8 +1112,12 @@ async function hereCommand(opts = {}) {
 }
 
 // src/index.ts
+import pc6 from "picocolors";
 var program = new Command();
-program.name("aman").description("Your complete AI companion \u2014 identity, memory, and tools in one command").version("0.5.2").action(() => {
+program.name("aman").description("Your complete AI companion \u2014 identity, memory, and tools in one command").version("0.5.4").action(() => {
+  for (const msg of runAutoHeal()) {
+    console.log(`  ${pc6.green("\u2714")} ${msg}`);
+  }
   const ecosystem = detectEcosystem();
   if (ecosystem.acore.installed) {
     statusCommand();
@@ -1081,7 +1126,12 @@ program.name("aman").description("Your complete AI companion \u2014 identity, me
   }
 });
 program.command("setup").description("Set up your AI companion (identity + memory + tools)").action(() => setupCommand());
-program.command("status").description("View your full ecosystem status").action(() => statusCommand());
+program.command("status").description("View your full ecosystem status").action(() => {
+  for (const msg of runAutoHeal()) {
+    console.log(`  ${pc6.green("\u2714")} ${msg}`);
+  }
+  statusCommand();
+});
 program.command("deploy").description("Deploy your AI companion (Docker, systemd, or cloud)").action(() => deployCommand());
 program.command("showcase [name]").description("Set up a showcase AI companion (rutin, kedai, monitor, ...)").option("--dry-run", "preview files without installing").option("--list", "list all available showcases").action(
   (name, opts) => showcaseCommand(name, opts)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aman_asmuei/aman",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Your complete AI companion — identity, memory, and tools in one command",
   "type": "module",
   "bin": {