@aman_asmuei/aman 0.5.0 → 0.5.2

package/README.md

@@ -92,8 +92,13 @@ Each package works independently. `aman` is the front door.
 | `aman` | First run: setup. After that: show status |
 | `aman setup` | Set up the full ecosystem |
 | `aman status` | View ecosystem status (all layers) |
+| `aman here` | Write a project context card (`.acore/context.md`) for the current directory |
 | `aman deploy` | Deploy your AI anywhere (Docker, Ollama, systemd) |
 
+### `aman here` — project context cards
+
+Run `aman here` in any repo to create a `.acore/context.md` with the detected stack and today's date. The file is read by [aman-claude-code](https://github.com/amanasmuei/aman-claude-code) on every session start and embedded into [aman-copilot](https://github.com/amanasmuei/aman-copilot)'s `copilot-instructions.md` at `init` time — so both surfaces know which project you're in. Use `--force` to overwrite an existing card non-interactively.
+
 After setup, use the individual CLIs for detailed management:
 
 ```bash
@@ -219,6 +224,81 @@ https://amanasmuei.github.io/acore/
 
 ChatGPT, Claude, Claude Code, Cursor, Windsurf, Gemini, Ollama, and any AI that accepts a system prompt.
 
+---
+
+## Full install (all surfaces)
+
+The one-command setup creates your global ecosystem. To light up every surface:
+
+```bash
+# 1. Ecosystem (identity + rules + eval)
+npx @aman_asmuei/aman@latest
+
+# 2. Persistent memory (MCP) — required for cross-surface memory sync
+npx @aman_asmuei/amem
+
+# 3a. Claude Code — plugin + live MCP tools
+claude plugin marketplace add amanasmuei/aman-claude-code
+claude plugin install aman-claude-code@aman
+# Plugin auto-installs the MCP tools on first session start. To install manually:
+# node ~/.claude/plugins/cache/aman/aman-claude-code/*/bin/install-mcp.mjs
+
+# 3b. VS Code Copilot Chat — per project
+cd /path/to/your/project
+npx @aman_asmuei/aman-copilot init
+npx @aman_asmuei/aman-copilot install-mcp --all
+# Then: reload VS Code window, switch Copilot Chat to Agent mode
+
+# 4. Per-project context card (optional, per repo)
+cd /path/to/your/project
+npx @aman_asmuei/aman here
+```
+
+Every step is idempotent — safe to re-run. The plugin + copilot auto-load identity/rules/memory from the global ecosystem; you only need to personalise once.
+
+---
+
+## Uninstall / reset
+
+### Soft reset — keep packages, wipe content, re-run setup
+
+```bash
+rm -rf ~/.acore ~/.arules ~/.aeval
+npx @aman_asmuei/aman@latest
+```
+
+Useful when your identity drifts and you want a clean slate without fully uninstalling.
+
+### Full uninstall — nothing aman-related on disk
+
+```bash
+# 1. Global ecosystem data
+rm -rf ~/.acore ~/.arules ~/.aeval ~/.aflow ~/.akit ~/.askill ~/.amem
+
+# 2. Claude Code plugin + MCP entry
+claude plugin uninstall aman-claude-code@aman
+claude plugin marketplace remove aman
+claude mcp remove aman 2>/dev/null || true
+
+# 3. VS Code + Copilot CLI MCP entries
+npx @aman_asmuei/aman-copilot uninstall-mcp --all
+
+# 4. Per-project files — find every .acore folder you opted in to
+find ~ -maxdepth 4 -type d -name .acore 2>/dev/null
+# Review the list, then delete by hand or:
+# find ~/Projects -maxdepth 4 -type d -name .acore -exec rm -rf {} +
+```
+
+### Per-project only — remove aman from one repo
+
+```bash
+# From the project root
+rm -rf .acore .github/copilot-instructions.md
+rm -f .github/prompts/{identity,rules,eval,remember,session-narrative}.prompt.md
+```
+
+The package `npx` binaries (`aman`, `amem`, `aman-copilot`, etc.) live in npm's cache — `npm cache clean --force` if you want those gone too, but they're tiny and usually not worth the trouble.
+
 ## License
 
 [MIT](LICENSE)

package/dist/index.js

@@ -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 }
   };
@@ -374,8 +384,39 @@ var ARCHETYPES = {
 async function setupCommand() {
   p.intro(pc.bold("aman") + " \u2014 your complete AI companion");
   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) {
-    p.log.success(`Identity: ${pc.dim("~/.acore/core.md")} already exists`);
+    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`);
+    }
   } else {
     p.log.step("Setting up your AI identity...");
     let userName = detectUserName();
@@ -421,10 +462,10 @@ 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 = path3.join(os2.homedir(), ".acore", "dev", "plugin");
+    fs4.mkdirSync(scopedAcoreDir, { recursive: true });
+    fs4.writeFileSync(path3.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 });
@@ -447,12 +488,15 @@ async function setupCommand() {
       fs4.writeFileSync(path3.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");
+    } else {
+      p.log.info(
+        `No project detected here \u2014 run ${pc.bold("aman here")} later from inside any repo to add per-project context.`
+      );
     }
     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 result = injectIntoFile(filePath, content);
       if (result.created) {
         p.log.success(`Created ${pc.dim(platformFile)} with identity`);
       } else {
@@ -514,10 +558,10 @@ async function setupCommand() {
       p.log.success(`Workflows: ${ecosystem.aflow.workflowCount} defined`);
     }
     if (doRules) {
-      const arulesDir = path3.join(home, ".arules");
+      const arulesDir = path3.join(home, ".arules", "dev", "plugin");
       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)`);
+      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`);
     }
@@ -546,6 +590,7 @@ async function setupCommand() {
     `  ${pc.green("\u2714")} Your AI companion is ready.`,
     "",
     `  ${pc.bold("aman status")}             See your full ecosystem`,
+    `  ${pc.bold("aman here")}               Add per-project context (.acore/context.md)`,
     `  ${pc.bold("acore customize")}         Change personality`,
     `  ${pc.bold("askill add testing")}      Install skills`,
     `  ${pc.bold("npx @aman_asmuei/amem")}   Enable automated memory`,
@@ -1027,7 +1072,7 @@ async function hereCommand(opts = {}) {
 
 // src/index.ts
 var program = new Command();
-program.name("aman").description("Your complete AI companion \u2014 identity, memory, and tools in one command").version("0.5.0").action(() => {
+program.name("aman").description("Your complete AI companion \u2014 identity, memory, and tools in one command").version("0.5.2").action(() => {
   const ecosystem = detectEcosystem();
   if (ecosystem.acore.installed) {
     statusCommand();

package/package.json

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