@aman_asmuei/aman 0.5.1 → 0.5.3

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";
@@ -76,9 +76,18 @@ function detectRole(cwd) {
 function isMcpPlatform(platform) {
   return platform === "claude-code" || platform === "cursor" || platform === "windsurf";
 }
+function resolveLayerFile(layerDir, filename, home) {
+  const homeDir = home ?? os.homedir();
+  const scopedPath = path.join(homeDir, layerDir, "dev", "plugin", filename);
+  const legacyPath = path.join(homeDir, layerDir, filename);
+  if (fs.existsSync(scopedPath)) return scopedPath;
+  if (fs.existsSync(legacyPath)) return legacyPath;
+  return null;
+}
 function detectEcosystem() {
   const home = os.homedir();
-  const acorePath = path.join(home, ".acore", "core.md");
+  const acoreResolvedPath = resolveLayerFile(".acore", "core.md");
+  const acorePath = acoreResolvedPath ?? path.join(home, ".acore", "dev", "plugin", "core.md");
   const akitPath = path.join(home, ".akit", "kit.md");
   const akitInstalledPath = path.join(home, ".akit", "installed.json");
   let akitToolCount = 0;
@@ -113,11 +122,12 @@ function detectEcosystem() {
     } catch {
     }
   }
-  const arulesPath = path.join(home, ".arules", "rules.md");
+  const arulesResolvedPath = resolveLayerFile(".arules", "rules.md");
+  const arulesPath = arulesResolvedPath ?? path.join(home, ".arules", "dev", "plugin", "rules.md");
   let arulesRuleCount = 0;
-  if (fs.existsSync(arulesPath)) {
+  if (arulesResolvedPath) {
     try {
-      const content = fs.readFileSync(arulesPath, "utf-8");
+      const content = fs.readFileSync(arulesResolvedPath, "utf-8");
       arulesRuleCount = (content.match(/^- /gm) || []).length;
     } catch {
     }
@@ -142,11 +152,11 @@ function detectEcosystem() {
     }
   }
   return {
-    acore: { installed: fs.existsSync(acorePath), path: acorePath },
+    acore: { installed: acoreResolvedPath !== null, path: acorePath },
     amem: { installed: amemInstalled },
     akit: { installed: fs.existsSync(akitPath), path: akitPath, toolCount: akitToolCount },
     aflow: { installed: fs.existsSync(aflowPath), path: aflowPath, workflowCount: aflowWorkflowCount },
-    arules: { installed: fs.existsSync(arulesPath), path: arulesPath, ruleCount: arulesRuleCount },
+    arules: { installed: arulesResolvedPath !== null, path: arulesPath, ruleCount: arulesRuleCount },
     aeval: { installed: fs.existsSync(aevalPath), path: aevalPath, sessions: aevalSessions },
     askill: { installed: fs.existsSync(askillPath), path: askillPath, skillCount: askillCount }
   };
@@ -256,6 +266,58 @@ 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";
+  }
+  return "ok";
+}
+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`;
+  }
+  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
 
@@ -373,9 +435,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();
   if (ecosystem.acore.installed) {
-    p.log.success(`Identity: ${pc.dim("~/.acore/core.md")} 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();
@@ -421,13 +486,13 @@ async function setupCommand() {
       DATE: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
       UPDATE_INSTRUCTIONS: getUpdateInstructions(platform)
     });
-    const globalDir = path3.join(os2.homedir(), ".acore");
-    fs4.mkdirSync(globalDir, { recursive: true });
-    fs4.writeFileSync(path3.join(globalDir, "core.md"), content, "utf-8");
-    p.log.success(`Created ${pc.dim("~/.acore/core.md")} (identity)`);
+    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}
@@ -444,9 +509,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.`
@@ -454,9 +519,8 @@ async function setupCommand() {
     }
     const platformFile = getPlatformFile(platform);
     if (platformFile) {
-      const globalContent = fs4.readFileSync(path3.join(globalDir, "core.md"), "utf-8");
-      const filePath = path3.join(process.cwd(), platformFile);
-      const result = injectIntoFile(filePath, globalContent);
+      const filePath = path4.join(process.cwd(), platformFile);
+      const result = injectIntoFile(filePath, content);
       if (result.created) {
         p.log.success(`Created ${pc.dim(platformFile)} with identity`);
       } else {
@@ -467,7 +531,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;
@@ -510,26 +574,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");
-      fs4.mkdirSync(arulesDir, { recursive: true });
-      fs4.writeFileSync(path3.join(arulesDir, "rules.md"), STARTER_RULES, "utf-8");
-      p.log.success(`Guardrails: created ${pc.dim("~/.arules/rules.md")} (24 rules)`);
+      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");
@@ -563,13 +627,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)}`);
@@ -634,8 +698,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() {
@@ -692,15 +756,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")}`);
@@ -736,20 +800,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)`);
@@ -826,18 +890,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);
   }
 }
 
@@ -967,14 +1031,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?`,
@@ -988,7 +1052,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:
@@ -1004,21 +1068,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;
@@ -1031,8 +1095,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.1").action(() => {
+program.name("aman").description("Your complete AI companion \u2014 identity, memory, and tools in one command").version("0.5.3").action(() => {
+  for (const msg of runAutoHeal()) {
+    console.log(`  ${pc6.green("\u2714")} ${msg}`);
+  }
   const ecosystem = detectEcosystem();
   if (ecosystem.acore.installed) {
     statusCommand();
@@ -1041,7 +1109,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.1",
+  "version": "0.5.3",
   "description": "Your complete AI companion — identity, memory, and tools in one command",
   "type": "module",
   "bin": {