@aman_asmuei/aman 0.1.1 → 0.2.0

package/dist/index.js

@@ -132,13 +132,23 @@ function detectEcosystem() {
     } 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 },
     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 }
+    aeval: { installed: fs.existsSync(aevalPath), path: aevalPath, sessions: aevalSessions },
+    askill: { installed: fs.existsSync(askillPath), path: askillPath, skillCount: askillCount }
   };
 }
 
@@ -246,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: {
@@ -366,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 {
@@ -376,28 +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`);
-  }
-  if (ecosystem.aflow.installed) {
-    p.log.success(`Workflows: ${ecosystem.aflow.workflowCount} defined`);
-  } else {
-    p.log.info(`Workflows: run ${pc.bold("npx @aman_asmuei/aflow init")} to add AI workflows`);
-  }
   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
@@ -441,6 +596,11 @@ function statusCommand() {
   } 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",
@@ -460,16 +620,17 @@ function statusCommand() {
   if (ecosystem.aflow.installed) score += 1;
   if (ecosystem.arules.installed) score += 1;
   if (ecosystem.aeval.installed) score += 1;
-  const levels = ["Not started", "Getting started", "Growing", "Building", "Strong", "Advanced", "Complete ecosystem"];
-  const colors = [pc2.red, pc2.red, pc2.yellow, pc2.yellow, pc2.cyan, pc2.cyan, pc2.green];
+  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}/6 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.1").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.1",
+  "version": "0.2.0",
   "description": "Your complete AI companion — identity, memory, and tools in one command",
   "type": "module",
   "bin": {