@aman_asmuei/aman 0.1.1 → 0.3.0

package/Dockerfile

@@ -0,0 +1,47 @@
+# aman ecosystem — full AI companion in one container
+# Includes: aman-agent (CLI) + achannel (Telegram/Discord/webhook) + aman-mcp + amem
+#
+# Build:  docker build -t aman .
+# Run:    docker run -it -e ANTHROPIC_API_KEY=sk-... aman
+# Serve:  docker run -d -p 3000:3000 -e ANTHROPIC_API_KEY=sk-... aman serve
+
+FROM node:22-alpine AS base
+
+# Install system dependencies
+RUN apk add --no-cache git curl
+
+WORKDIR /app
+
+# Install all ecosystem packages globally
+RUN npm install -g \
+  @aman_asmuei/aman-agent@latest \
+  @aman_asmuei/aman-mcp@latest \
+  @aman_asmuei/achannel@latest \
+  @aman_asmuei/aman@latest
+
+# Create ecosystem directories
+RUN mkdir -p /root/.acore /root/.amem /root/.akit /root/.aflow \
+  /root/.arules /root/.aeval /root/.askill /root/.aman-agent
+
+# Default environment
+ENV NODE_ENV=production
+ENV AMEM_DB_PATH=/root/.amem/memory.db
+
+# Volumes for persistent data
+VOLUME ["/root/.acore", "/root/.amem", "/root/.aman-agent"]
+
+# Expose webhook port (achannel serve)
+EXPOSE 3000
+
+# Healthcheck for server mode
+HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
+  CMD curl -f http://localhost:3000/status || exit 1
+
+# Entrypoint script
+COPY docker-entrypoint.sh /usr/local/bin/
+RUN chmod +x /usr/local/bin/docker-entrypoint.sh
+
+ENTRYPOINT ["docker-entrypoint.sh"]
+
+# Default: interactive CLI mode
+CMD ["agent"]

package/deploy/systemd/aman.service

@@ -0,0 +1,29 @@
+[Unit]
+Description=aman AI companion server
+After=network.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=aman
+WorkingDirectory=/home/aman
+ExecStart=/usr/bin/npx @aman_asmuei/achannel serve
+Restart=always
+RestartSec=10
+
+# Environment — set your API key
+EnvironmentFile=/home/aman/.aman-agent/env
+
+# Logging
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=aman
+
+# Security hardening
+NoNewPrivileges=true
+ProtectSystem=strict
+ProtectHome=read-only
+ReadWritePaths=/home/aman/.acore /home/aman/.amem /home/aman/.aman-agent /home/aman/.aeval /home/aman/.arules /home/aman/.aflow /home/aman/.akit /home/aman/.askill
+
+[Install]
+WantedBy=multi-user.target

package/dist/index.js

@@ -32,8 +32,8 @@ function detectPlatform(cwd) {
       const raw = fs.readFileSync(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.platform === "string") {
-        const p3 = parsed.platform;
-        if (p3 === "claude-code" || p3 === "cursor" || p3 === "windsurf") return p3;
+        const p4 = parsed.platform;
+        if (p4 === "claude-code" || p4 === "cursor" || p4 === "windsurf") return p4;
       }
     } catch {
     }
@@ -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,225 @@ 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/commands/deploy.ts
+import fs6 from "fs";
+import path4 from "path";
+import * as p3 from "@clack/prompts";
+import pc3 from "picocolors";
+async function deployCommand() {
+  p3.intro(pc3.bold("aman deploy") + pc3.dim(" \u2014 deploy your AI companion anywhere"));
+  const method = await p3.select({
+    message: "How do you want to deploy?",
+    options: [
+      { value: "docker", label: "Docker Compose", hint: "VPS, home server, Raspberry Pi" },
+      { value: "ollama", label: "Docker + Ollama", hint: "fully local, no API key needed" },
+      { value: "systemd", label: "Systemd service", hint: "bare metal Linux / Raspberry Pi" },
+      { value: "manual", label: "Show me the commands", hint: "I'll do it myself" }
+    ]
+  });
+  if (p3.isCancel(method)) {
+    p3.cancel("Cancelled.");
+    return;
+  }
+  const cwd = process.cwd();
+  switch (method) {
+    case "docker": {
+      await deployDocker(cwd);
+      break;
+    }
+    case "ollama": {
+      await deployOllama(cwd);
+      break;
+    }
+    case "systemd": {
+      deploySystemd();
+      break;
+    }
+    case "manual": {
+      deployManual();
+      break;
+    }
+  }
+  p3.outro(pc3.green("Done!"));
+}
+async function deployDocker(cwd) {
+  const apiKey = await p3.text({
+    message: "Your LLM API key (Anthropic or OpenAI):",
+    placeholder: "sk-ant-... or sk-...",
+    validate: (v) => v.length < 10 ? "API key too short" : void 0
+  });
+  if (p3.isCancel(apiKey)) return;
+  const isAnthropic = apiKey.startsWith("sk-ant");
+  const provider = isAnthropic ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
+  const envContent = `# aman ecosystem \u2014 deployment config
+${provider}=${apiKey}
+AMAN_AI_NAME=Aman
+AMAN_MODEL=${isAnthropic ? "claude-sonnet-4-6" : "gpt-4o"}
+
+# Optional: Telegram/Discord bots
+# TELEGRAM_BOT_TOKEN=
+# DISCORD_BOT_TOKEN=
+`;
+  const envPath = path4.join(cwd, ".env");
+  fs6.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);
+  } catch {
+  }
+  p3.log.success(`Created ${pc3.bold("Dockerfile")} + ${pc3.bold("docker-compose.yml")}`);
+  p3.note(
+    `${pc3.bold("Start your companion:")}
+
+  docker compose up -d
+
+${pc3.bold("Access:")}
+  Webhook API:  http://localhost:3000/chat
+  Health check: http://localhost:3000/status
+
+${pc3.bold("Interactive CLI:")}
+  docker compose run --rm aman-server agent
+
+${pc3.bold("View logs:")}
+  docker compose logs -f`,
+    "Next steps"
+  );
+}
+async function deployOllama(cwd) {
+  const model = await p3.text({
+    message: "Ollama model to use:",
+    placeholder: "llama3.2",
+    initialValue: "llama3.2"
+  });
+  if (p3.isCancel(model)) return;
+  const envContent = `# aman ecosystem \u2014 local deployment (no API key needed)
+AMAN_AI_NAME=Aman
+AMAN_MODEL=${model}
+
+# Optional: Telegram/Discord bots
+# TELEGRAM_BOT_TOKEN=
+# DISCORD_BOT_TOKEN=
+`;
+  const envPath = path4.join(cwd, ".env");
+  fs6.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);
+  }
+  try {
+    fs6.chmodSync(path4.join(cwd, "docker-entrypoint.sh"), 493);
+  } catch {
+  }
+  p3.log.success(`Created ${pc3.bold("Dockerfile")} + ${pc3.bold("docker-compose.yml")} (with Ollama)`);
+  p3.note(
+    `${pc3.bold("Start your companion (fully local):")}
+
+  docker compose up -d
+
+  First run downloads ${model} (~2GB). After that it's instant.
+
+${pc3.bold("Access:")}
+  Webhook API:  http://localhost:3000/chat
+  Ollama:       http://localhost:11434
+
+${pc3.bold("Works on:")}
+  Raspberry Pi 4/5 (ARM64), any Linux, macOS, Windows`,
+    "Next steps"
+  );
+}
+function deploySystemd() {
+  p3.note(
+    `${pc3.bold("1. Install Node.js 20+:")}
+  curl -fsSL https://deb.nodesource.com/setup_22.x | sudo bash -
+  sudo apt install -y nodejs
+
+${pc3.bold("2. Create aman user:")}
+  sudo useradd -m -s /bin/bash aman
+  sudo -u aman npm install -g @aman_asmuei/achannel @aman_asmuei/aman-mcp
+
+${pc3.bold("3. Configure API key:")}
+  sudo mkdir -p /home/aman/.aman-agent
+  echo 'ANTHROPIC_API_KEY=sk-ant-...' | sudo tee /home/aman/.aman-agent/env
+
+${pc3.bold("4. Install service:")}
+  sudo cp aman.service /etc/systemd/system/
+  sudo systemctl daemon-reload
+  sudo systemctl enable --now aman
+
+${pc3.bold("5. Check status:")}
+  sudo systemctl status aman
+  sudo journalctl -u aman -f`,
+    "Systemd deployment (Raspberry Pi / bare metal)"
+  );
+}
+function deployManual() {
+  p3.note(
+    `${pc3.bold("Docker (one command):")}
+  docker run -d -p 3000:3000 \\
+    -e ANTHROPIC_API_KEY=sk-ant-... \\
+    -v aman-data:/root/.acore \\
+    -v aman-memory:/root/.amem \\
+    ghcr.io/amanasmuei/aman serve
+
+${pc3.bold("Docker + Ollama (fully local):")}
+  docker run -d --name ollama ollama/ollama
+  docker exec ollama ollama pull llama3.2
+  docker run -d -p 3000:3000 \\
+    --link ollama \\
+    -e OLLAMA_HOST=http://ollama:11434 \\
+    ghcr.io/amanasmuei/aman serve
+
+${pc3.bold("npm (any server):")}
+  npm install -g @aman_asmuei/achannel @aman_asmuei/aman-mcp
+  ANTHROPIC_API_KEY=sk-ant-... achannel serve
+
+${pc3.bold("Raspberry Pi:")}
+  curl -fsSL https://deb.nodesource.com/setup_22.x | sudo bash -
+  sudo apt install -y nodejs
+  npm install -g @aman_asmuei/achannel @aman_asmuei/aman-mcp
+  ANTHROPIC_API_KEY=sk-ant-... achannel serve`,
+    "Manual deployment commands"
+  );
+}
+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);
+  }
+  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;
+  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);
+  }
+}
+
 // 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.3.0").action(() => {
   const ecosystem = detectEcosystem();
   if (ecosystem.acore.installed) {
     statusCommand();
@@ -479,4 +848,5 @@ 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("deploy").description("Deploy your AI companion (Docker, systemd, or cloud)").action(() => deployCommand());
 program.parse();

package/docker-compose.ollama.yml

@@ -0,0 +1,65 @@
+# aman ecosystem — fully local with Ollama (no API key needed)
+# Usage: docker compose -f docker-compose.ollama.yml up -d
+#
+# First run pulls llama3.2 model (~2GB download)
+# Works on: Raspberry Pi 4/5 (ARM64), any Linux/Mac with Docker
+
+services:
+  ollama:
+    image: ollama/ollama:latest
+    restart: unless-stopped
+    volumes:
+      - ollama-models:/root/.ollama
+    ports:
+      - "11434:11434"
+    # Uncomment for GPU support:
+    # deploy:
+    #   resources:
+    #     reservations:
+    #       devices:
+    #         - capabilities: [gpu]
+
+  ollama-init:
+    image: ollama/ollama:latest
+    depends_on:
+      - ollama
+    restart: "no"
+    entrypoint: >
+      sh -c "sleep 5 && ollama pull llama3.2"
+    environment:
+      - OLLAMA_HOST=http://ollama:11434
+
+  aman-server:
+    build: .
+    command: serve
+    restart: unless-stopped
+    depends_on:
+      - ollama
+    ports:
+      - "3000:3000"
+    environment:
+      - OLLAMA_HOST=http://ollama:11434
+      - AMAN_AI_NAME=${AMAN_AI_NAME:-Aman}
+      - AMAN_MODEL=${AMAN_MODEL:-llama3.2}
+      - TELEGRAM_BOT_TOKEN=${TELEGRAM_BOT_TOKEN:-}
+      - DISCORD_BOT_TOKEN=${DISCORD_BOT_TOKEN:-}
+    volumes:
+      - aman-identity:/root/.acore
+      - aman-memory:/root/.amem
+      - aman-config:/root/.aman-agent
+      - aman-rules:/root/.arules
+      - aman-workflows:/root/.aflow
+      - aman-eval:/root/.aeval
+      - aman-skills:/root/.askill
+      - aman-tools:/root/.akit
+
+volumes:
+  ollama-models:
+  aman-identity:
+  aman-memory:
+  aman-config:
+  aman-rules:
+  aman-workflows:
+  aman-eval:
+  aman-skills:
+  aman-tools:

package/docker-compose.yml

@@ -0,0 +1,40 @@
+# aman ecosystem — full deployment
+# Usage: docker compose up -d
+#
+# Modes:
+#   aman-server  → always-on webhook/Telegram/Discord server
+#   aman-agent   → interactive CLI (attach with: docker attach aman-agent)
+
+services:
+  aman-server:
+    build: .
+    command: serve
+    restart: unless-stopped
+    ports:
+      - "3000:3000"
+    environment:
+      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
+      - OPENAI_API_KEY=${OPENAI_API_KEY:-}
+      - AMAN_AI_NAME=${AMAN_AI_NAME:-Aman}
+      - AMAN_MODEL=${AMAN_MODEL:-claude-sonnet-4-6}
+      - TELEGRAM_BOT_TOKEN=${TELEGRAM_BOT_TOKEN:-}
+      - DISCORD_BOT_TOKEN=${DISCORD_BOT_TOKEN:-}
+    volumes:
+      - aman-identity:/root/.acore
+      - aman-memory:/root/.amem
+      - aman-config:/root/.aman-agent
+      - aman-rules:/root/.arules
+      - aman-workflows:/root/.aflow
+      - aman-eval:/root/.aeval
+      - aman-skills:/root/.askill
+      - aman-tools:/root/.akit
+
+volumes:
+  aman-identity:
+  aman-memory:
+  aman-config:
+  aman-rules:
+  aman-workflows:
+  aman-eval:
+  aman-skills:
+  aman-tools:

package/docker-entrypoint.sh

@@ -0,0 +1,165 @@
+#!/bin/sh
+set -e
+
+# aman ecosystem — Docker entrypoint
+# Modes:
+#   agent    → interactive CLI (default)
+#   serve    → achannel webhook/Telegram/Discord server
+#   setup    → run ecosystem setup
+#   status   → show ecosystem status
+
+MODE="${1:-agent}"
+
+# Auto-create minimal identity if none exists
+if [ ! -f /root/.acore/core.md ]; then
+  echo "  First run — creating default identity..."
+  AI_NAME="${AMAN_AI_NAME:-Aman}"
+  cat > /root/.acore/core.md << EOF
+# ${AI_NAME}
+
+## Identity
+- Role: ${AI_NAME} is your AI companion
+- Personality: helpful, direct, adaptive
+- Communication: clear and concise
+- Values: honesty, simplicity, understanding
+- Boundaries: won't pretend to be human
+
+---
+
+## Relationship
+- Name: [user]
+- Role: [role]
+- Nicknames: []
+- Communication: [updated over time]
+- Detail level: balanced
+- Domain: [detected from project]
+- Personal: []
+- Learned patterns: []
+
+---
+
+## Session
+- Last updated: $(date +%Y-%m-%d)
+- Resume: [starting fresh]
+- Active topics: []
+- Recent decisions: []
+- Temp notes: []
+
+---
+
+## Dynamics
+
+### Trust & Rapport
+- Level: 3
+- Trajectory: building
+- Evidence: []
+- Unlocked behaviors: []
+
+### Emotional Patterns
+- Baseline energy: steady
+- Stress signals: []
+- Support style: problem-solve
+- Current read: fresh start
+
+### Conflict & Repair
+- History: []
+- Conflict style: direct
+- Learned response: []
+
+---
+
+## Context Modes
+
+> Active mode inferred from conversation context.
+
+### Default
+- Tone: casual-professional
+- Detail: balanced
+- Initiative: proactive
+
+---
+
+## Memory Lifecycle
+
+### Importance
+- Critical: [user boundaries, core preferences]
+- Persistent: [projects, tech stack]
+- Ephemeral: [temporary context]
+
+### Size
+- Target: under 2000 tokens
+EOF
+  echo "  Identity created: ${AI_NAME}"
+fi
+
+# Auto-create aman-agent config if API key is provided
+if [ ! -f /root/.aman-agent/config.json ]; then
+  if [ -n "$ANTHROPIC_API_KEY" ]; then
+    MODEL="${AMAN_MODEL:-claude-sonnet-4-6}"
+    cat > /root/.aman-agent/config.json << EOF
+{
+  "provider": "anthropic",
+  "apiKey": "${ANTHROPIC_API_KEY}",
+  "model": "${MODEL}",
+  "hooks": {
+    "memoryRecall": true,
+    "sessionResume": true,
+    "rulesCheck": true,
+    "workflowSuggest": true,
+    "evalPrompt": false,
+    "autoSessionSave": true,
+    "extractMemories": true,
+    "featureHints": true,
+    "personalityAdapt": true
+  }
+}
+EOF
+    echo "  Config created: Anthropic / ${MODEL}"
+  elif [ -n "$OPENAI_API_KEY" ]; then
+    MODEL="${AMAN_MODEL:-gpt-4o}"
+    cat > /root/.aman-agent/config.json << EOF
+{
+  "provider": "openai",
+  "apiKey": "${OPENAI_API_KEY}",
+  "model": "${MODEL}",
+  "hooks": {
+    "memoryRecall": true,
+    "sessionResume": true,
+    "rulesCheck": true,
+    "workflowSuggest": true,
+    "evalPrompt": false,
+    "autoSessionSave": true,
+    "extractMemories": true,
+    "featureHints": true,
+    "personalityAdapt": true
+  }
+}
+EOF
+    echo "  Config created: OpenAI / ${MODEL}"
+  fi
+fi
+
+case "$MODE" in
+  agent)
+    echo "  Starting aman-agent (interactive)..."
+    exec aman-agent
+    ;;
+  serve)
+    echo "  Starting achannel server on :3000..."
+    exec achannel serve
+    ;;
+  setup)
+    exec aman setup
+    ;;
+  status)
+    exec aman status
+    ;;
+  sh|bash)
+    exec /bin/sh
+    ;;
+  *)
+    echo "Unknown mode: $MODE"
+    echo "Usage: docker run aman [agent|serve|setup|status|sh]"
+    exit 1
+    ;;
+esac

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aman_asmuei/aman",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Your complete AI companion — identity, memory, and tools in one command",
   "type": "module",
   "bin": {
@@ -10,7 +10,12 @@
   "files": [
     "dist",
     "bin",
-    "template"
+    "template",
+    "deploy",
+    "Dockerfile",
+    "docker-entrypoint.sh",
+    "docker-compose.yml",
+    "docker-compose.ollama.yml"
   ],
   "scripts": {
     "build": "tsup",