@aman_asmuei/aman 0.1.0 → 0.2.0

package/README.md

@@ -9,7 +9,7 @@
 
 ### Your complete AI companion.
 
-Identity + Memory + Tools — one command, any AI.
+Identity + Memory + Tools + Workflows + Guardrails + Evaluation — one command, any AI.
 
 <br>
 
@@ -31,16 +31,14 @@ Sets up your complete AI ecosystem:
 ```
 ◆ aman — your complete AI companion
 
-✔ Created ~/.acore/core.md (identity)
-✔ Memory: run npx @aman_asmuei/amem to add automated memory
-✔ Tools: run npx @aman_asmuei/akit add github to add capabilities
+✔ Identity:   created ~/.acore/core.md
+✔ Memory:     run npx @aman_asmuei/amem to enable
+✔ Tools:      run npx @aman_asmuei/akit add github
+✔ Workflows:  run npx @aman_asmuei/aflow init
+✔ Guardrails: run npx @aman_asmuei/arules init
+✔ Evaluation: run npx @aman_asmuei/aeval init
 
   ✔ Your AI companion is ready.
-
-  aman status             See your full ecosystem
-  acore customize         Change personality
-  akit add <tool>         Add tools
-  npx @aman_asmuei/amem   Enable automated memory
 ```
 
 ---
@@ -49,17 +47,23 @@ Sets up your complete AI ecosystem:
 
 ```
 aman
-├── acore     →  identity    →  who your AI IS
-├── amem      →  memory      →  what your AI KNOWS
-└── akit      →  tools       →  what your AI CAN DO
+├── acore   →  identity     →  who your AI IS
+├── amem    →  memory       →  what your AI KNOWS
+├── akit    →  tools        →  what your AI CAN DO
+├── aflow   →  workflows    →  HOW your AI works
+├── arules  →  guardrails   →  what your AI WON'T do
+└── aeval   →  evaluation   →  how GOOD your AI is
 ```
 
 | Layer | Package | What it does |
 |:------|:--------|:-------------|
 | Identity | [acore](https://github.com/amanasmuei/acore) | Personality, values, relationship memory |
 | Memory | [amem](https://github.com/amanasmuei/amem) | Automated knowledge storage (MCP) |
-| Tools | [akit](https://github.com/amanasmuei/akit) | Portable AI capabilities (MCP + manual) |
-| **Unified** | **aman** | **One command to set up everything** |
+| Tools | [akit](https://github.com/amanasmuei/akit) | 15 portable AI tools (MCP + manual fallback) |
+| Workflows | [aflow](https://github.com/amanasmuei/aflow) | Reusable AI workflows (code review, bug fix, etc.) |
+| Guardrails | [arules](https://github.com/amanasmuei/arules) | Safety boundaries and permissions |
+| Evaluation | [aeval](https://github.com/amanasmuei/aeval) | Relationship tracking and session logging |
+| **Unified** | **[aman](https://github.com/amanasmuei/aman)** | **One command to set up everything** |
 
 Each package works independently. `aman` is the front door.
 
@@ -70,18 +74,22 @@ Each package works independently. `aman` is the front door.
 | Command | What it does |
 |:--------|:------------|
 | `aman` | First run: setup. After that: show status |
-| `aman setup` | Set up identity + memory + tools |
-| `aman status` | View your full ecosystem status |
+| `aman setup` | Set up the full ecosystem |
+| `aman status` | View ecosystem status (all 6 layers) |
 
 After setup, use the individual CLIs for detailed management:
 
 ```bash
 acore customize         # change AI personality
-acore show              # view identity
+acore doctor            # health check identity
 akit add github         # add tools
 akit search database    # find tools
-acore doctor            # health check identity
-akit doctor             # health check tools
+aflow init              # set up AI workflows
+aflow list              # view workflows
+arules init             # set up guardrails
+arules add Coding       # add a coding rule
+aeval log               # log a session
+aeval report            # view relationship report
 ```
 
 ---
@@ -93,19 +101,47 @@ $ aman status
 
 ◆ aman — ecosystem status
 
-✔ Identity: Companion + Aman
-✔ Memory: amem connected (automated)
-✔ Tools: 3 installed
-✔ Platform: Claude Code (auto-save + MCP)
+✔ Identity:   Companion + Aman
+✔ Memory:     amem connected (automated)
+✔ Tools:      3 installed
+✔ Workflows:  4 defined
+✔ Guardrails: 24 rules
+✔ Evaluation: 12 sessions tracked
+✔ Platform:   Claude Code (auto-save + MCP)
+
+  Ecosystem: Complete ecosystem (6/6 layers active)
+```
+
+---
+
+## How It All Connects
 
-  Ecosystem: Complete ecosystem (3/3 layers active)
+Every layer is a markdown file. acore auto-injects all of them into your AI's system prompt:
+
+```
+CLAUDE.md / .cursorrules / .windsurfrules
+  ├── core.md    (identity — acore)
+  ├── context.md (project — acore)
+  ├── kit.md     (tools — akit)
+  ├── flow.md    (workflows — aflow)
+  └── rules.md   (guardrails — arules)
 ```
 
+Your AI reads these files and behaves accordingly. Switch platforms? Bring your files.
+
+---
+
+## Not a Developer?
+
+Generate your AI identity from a browser — no terminal needed:
+
+https://amanasmuei.github.io/acore/
+
 ---
 
 ## Works With
 
-ChatGPT, Claude, Claude Code, Cursor, Windsurf, Gemini, and any AI that accepts a system prompt.
+ChatGPT, Claude, Claude Code, Cursor, Windsurf, Gemini, Ollama, and any AI that accepts a system prompt.
 
 ## License
 
@@ -115,6 +151,6 @@ ChatGPT, Claude, Claude Code, Cursor, Windsurf, Gemini, and any AI that accepts
 
 <div align="center">
 
-**One command. Complete AI companion. Any platform.**
+**One command. 6 layers. Any AI. Your companion.**
 
 </div>

package/dist/index.js

@@ -104,10 +104,51 @@ function detectEcosystem() {
       }
     }
   }
+  const aflowPath = path.join(home, ".aflow", "flow.md");
+  let aflowWorkflowCount = 0;
+  if (fs.existsSync(aflowPath)) {
+    try {
+      const content = fs.readFileSync(aflowPath, "utf-8");
+      aflowWorkflowCount = (content.match(/^## /gm) || []).length;
+    } catch {
+    }
+  }
+  const arulesPath = path.join(home, ".arules", "rules.md");
+  let arulesRuleCount = 0;
+  if (fs.existsSync(arulesPath)) {
+    try {
+      const content = fs.readFileSync(arulesPath, "utf-8");
+      arulesRuleCount = (content.match(/^- /gm) || []).length;
+    } catch {
+    }
+  }
+  const aevalPath = path.join(home, ".aeval", "eval.md");
+  let aevalSessions = 0;
+  if (fs.existsSync(aevalPath)) {
+    try {
+      const content = fs.readFileSync(aevalPath, "utf-8");
+      const match = content.match(/- Sessions: (\d+)/);
+      aevalSessions = match ? parseInt(match[1], 10) : 0;
+    } catch {
+    }
+  }
+  const askillPath = path.join(home, ".askill", "skills.md");
+  let askillCount = 0;
+  if (fs.existsSync(askillPath)) {
+    try {
+      const content = fs.readFileSync(askillPath, "utf-8");
+      askillCount = (content.match(/^## /gm) || []).length;
+    } catch {
+    }
+  }
   return {
     acore: { installed: fs.existsSync(acorePath), path: acorePath },
     amem: { installed: amemInstalled },
-    akit: { installed: fs.existsSync(akitPath), path: akitPath, toolCount: akitToolCount }
+    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 },
+    aeval: { installed: fs.existsSync(aevalPath), path: aevalPath, sessions: aevalSessions },
+    askill: { installed: fs.existsSync(askillPath), path: askillPath, skillCount: askillCount }
   };
 }
 
@@ -215,6 +256,93 @@ function getPlatformFile(platform) {
   }
 }
 
+// src/templates.ts
+var STARTER_FLOW = `# My Workflows
+
+## code-review
+When asked to review code:
+1. Analyze for bugs, logic errors, and edge cases
+2. Check for security vulnerabilities (OWASP top 10)
+3. Evaluate code style and maintainability
+4. Summarize findings with severity ratings (critical/warning/info)
+5. Suggest specific fixes with code examples
+
+## bug-fix
+When asked to fix a bug:
+1. Reproduce \u2014 understand the expected vs actual behavior
+2. Locate \u2014 find the root cause in the codebase
+3. Fix \u2014 implement the minimal change that fixes the issue
+4. Test \u2014 verify the fix works and doesn't break other things
+5. Document \u2014 explain what was wrong and why the fix works
+
+## feature-build
+When asked to build a feature:
+1. Clarify \u2014 ask questions until requirements are clear
+2. Design \u2014 propose an approach, get approval
+3. Implement \u2014 write the code in small, testable increments
+4. Test \u2014 write and run tests for the new code
+5. Review \u2014 check for edge cases, security, and performance
+
+## daily-standup
+When starting a new session:
+1. Check git log for recent changes
+2. Review open PRs and issues
+3. Summarize: what was done, what's in progress, what's blocked
+4. Ask what to focus on today
+`;
+var STARTER_RULES = `# My AI Rules
+
+## Always
+- Ask before deleting files or data
+- Explain your reasoning before making changes
+- Flag security concerns immediately
+- Respect code review processes
+
+## Never
+- Push directly to main/master without approval
+- Expose secrets, API keys, or credentials in code
+- Make changes to production systems without confirmation
+- Skip tests when fixing bugs
+
+## Coding
+- Follow existing code style and conventions
+- Prefer simple solutions over clever ones
+- Write tests for new functionality
+- Keep PRs focused and small
+
+## Communication
+- Be direct \u2014 lead with the answer
+- Admit when you don't know something
+- Ask clarifying questions before assuming
+- Flag when a task is outside your expertise
+
+## Data
+- Never log or expose personal information
+- Treat user data as confidential
+- Ask before accessing external APIs
+- Don't store credentials in plain text
+
+## Team
+- Follow the team's branching strategy
+- Respect code ownership boundaries
+- Tag relevant people for review
+- Document breaking changes
+`;
+var STARTER_EVAL = `# AI Relationship Metrics
+
+## Overview
+- Sessions: 0
+- First session: {{DATE}}
+- Trust level: 3/5
+- Trajectory: building
+
+## Timeline
+
+## Milestones
+
+## Patterns
+`;
+
 // src/commands/setup.ts
 var ARCHETYPES = {
   pragmatist: {
@@ -335,6 +463,74 @@ async function setupCommand() {
     if (stack) inferredParts.push(stack);
     p.log.info(`Inferred: ${pc.dim(inferredParts.join(" \xB7 "))}`);
   }
+  const home = os2.homedir();
+  const aflowExists = ecosystem.aflow.installed;
+  const arulesExists = ecosystem.arules.installed;
+  const aevalExists = ecosystem.aeval.installed;
+  if (aflowExists && arulesExists && aevalExists) {
+    p.log.success(`Workflows: ${ecosystem.aflow.workflowCount} defined`);
+    p.log.success(`Guardrails: ${ecosystem.arules.ruleCount} rules`);
+    p.log.success("Evaluation: already configured");
+  } else {
+    const setupChoice = await p.select({
+      message: "Set up additional layers?",
+      options: [
+        { value: "all", label: "Yes, set up everything", hint: "recommended" },
+        { value: "choose", label: "Let me choose" },
+        { value: "skip", label: "Skip for now" }
+      ],
+      initialValue: "all"
+    });
+    if (p.isCancel(setupChoice)) process.exit(0);
+    let doFlow = false;
+    let doRules = false;
+    let doEval = false;
+    if (setupChoice === "all") {
+      doFlow = !aflowExists;
+      doRules = !arulesExists;
+      doEval = !aevalExists;
+    } else if (setupChoice === "choose") {
+      const layers = await p.multiselect({
+        message: "Which layers?",
+        options: [
+          ...!aflowExists ? [{ value: "flow", label: "Workflows", hint: "4 starter workflows" }] : [],
+          ...!arulesExists ? [{ value: "rules", label: "Guardrails", hint: "24 starter rules" }] : [],
+          ...!aevalExists ? [{ value: "eval", label: "Evaluation", hint: "track relationship metrics" }] : []
+        ],
+        required: false
+      });
+      if (p.isCancel(layers)) process.exit(0);
+      const selected = layers;
+      doFlow = selected.includes("flow");
+      doRules = selected.includes("rules");
+      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");
+      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)`);
+    } 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 today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      fs4.writeFileSync(path3.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");
+    }
+  }
   if (ecosystem.amem.installed) {
     p.log.success("Memory: amem connected");
   } else {
@@ -345,23 +541,18 @@ async function setupCommand() {
       p.log.info(`Memory: built-in via core.md (upgrade with ${pc.bold("npx @aman_asmuei/amem")})`);
     }
   }
-  if (ecosystem.akit.installed) {
-    p.log.success(`Tools: ${ecosystem.akit.toolCount} tools configured`);
-  } else {
-    p.log.info(`Tools: run ${pc.bold("npx @aman_asmuei/akit add github")} to add capabilities`);
-  }
   const card = [
     "",
     `  ${pc.green("\u2714")} Your AI companion is ready.`,
     "",
     `  ${pc.bold("aman status")}             See your full ecosystem`,
     `  ${pc.bold("acore customize")}         Change personality`,
-    `  ${pc.bold("akit add <tool>")}         Add tools`,
+    `  ${pc.bold("askill add testing")}      Install skills`,
     `  ${pc.bold("npx @aman_asmuei/amem")}   Enable automated memory`,
     ""
   ];
   p.note(card.join("\n"), "");
-  p.outro(pc.dim("Identity + Memory + Tools \u2014 one ecosystem."));
+  p.outro(pc.dim("Identity + Workflows + Guardrails + Evaluation \u2014 one ecosystem."));
 }
 
 // src/commands/status.ts
@@ -390,6 +581,26 @@ function statusCommand() {
   } else {
     p2.log.warning(`Tools: none \u2014 ${pc2.dim("npx @aman_asmuei/akit add github")}`);
   }
+  if (ecosystem.aflow.installed) {
+    p2.log.success(`Workflows: ${ecosystem.aflow.workflowCount} defined \u2014 ${pc2.dim("aflow list for details")}`);
+  } else {
+    p2.log.warning(`Workflows: none \u2014 ${pc2.dim("npx @aman_asmuei/aflow init")}`);
+  }
+  if (ecosystem.arules.installed) {
+    p2.log.success(`Guardrails: ${ecosystem.arules.ruleCount} rules defined \u2014 ${pc2.dim("arules list for details")}`);
+  } else {
+    p2.log.warning(`Guardrails: none \u2014 ${pc2.dim("npx @aman_asmuei/arules init")}`);
+  }
+  if (ecosystem.aeval.installed) {
+    p2.log.success(`Evaluation: ${ecosystem.aeval.sessions} sessions tracked \u2014 ${pc2.dim("aeval report")}`);
+  } else {
+    p2.log.warning(`Evaluation: not tracking \u2014 ${pc2.dim("npx @aman_asmuei/aeval init")}`);
+  }
+  if (ecosystem.askill.installed) {
+    p2.log.success(`Skills: ${ecosystem.askill.skillCount} installed \u2014 ${pc2.dim("askill list for details")}`);
+  } else {
+    p2.log.warning(`Skills: none \u2014 ${pc2.dim("npx @aman_asmuei/askill add testing")}`);
+  }
   const platformLabels = {
     "claude-code": "Claude Code",
     cursor: "Cursor",
@@ -406,16 +617,20 @@ function statusCommand() {
   if (ecosystem.acore.installed) score += 1;
   if (ecosystem.amem.installed) score += 1;
   if (ecosystem.akit.installed) score += 1;
-  const levels = ["Not started", "Getting started", "Growing", "Complete ecosystem"];
-  const colors = [pc2.red, pc2.yellow, pc2.cyan, pc2.green];
+  if (ecosystem.aflow.installed) score += 1;
+  if (ecosystem.arules.installed) score += 1;
+  if (ecosystem.aeval.installed) score += 1;
+  if (ecosystem.askill.installed) score += 1;
+  const levels = ["Not started", "Getting started", "Growing", "Building", "Expanding", "Strong", "Advanced", "Complete ecosystem"];
+  const colors = [pc2.red, pc2.red, pc2.yellow, pc2.yellow, pc2.cyan, pc2.cyan, pc2.cyan, pc2.green];
   p2.log.message("");
-  p2.log.info(`Ecosystem: ${colors[score](levels[score])} (${score}/3 layers active)`);
+  p2.log.info(`Ecosystem: ${colors[score](levels[score])} (${score}/7 layers active)`);
   p2.outro("");
 }
 
 // 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.1.0").action(() => {
+program.name("aman").description("Your complete AI companion \u2014 identity, memory, and tools in one command").version("0.2.0").action(() => {
   const ecosystem = detectEcosystem();
   if (ecosystem.acore.installed) {
     statusCommand();

package/package.json

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