@aman_asmuei/aman 0.2.0 → 0.3.1

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/README.md

@@ -9,7 +9,7 @@
 
 ### Your complete AI companion.
 
-Identity + Memory + Tools + Workflows + Guardrails + Evaluation — one command, any AI.
+Identity + Memory + Tools + Workflows + Guardrails + Skills + Evaluation — setup, deploy, run anywhere.
 
 <br>
 
@@ -47,23 +47,29 @@ 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
-├── aflow   →  workflows    →  HOW your AI works
-├── arules  →  guardrails   →  what your AI WON'T do
-└── aeval   →  evaluation   →  how GOOD your AI is
+├── 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
+├── askill      →  skills       →  what your AI MASTERS
+├── aeval       →  evaluation   →  how GOOD your AI is
+├── achannel    →  channels     →  WHERE your AI lives
+└── aman-agent  →  runtime      →  the engine that runs it all
 ```
 
 | 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) |
+| Identity | [acore](https://github.com/amanasmuei/acore) | Personality, values, appearance, relationship memory |
+| Memory | [amem](https://github.com/amanasmuei/amem) | Automated knowledge storage with semantic search (MCP) |
 | 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 |
+| Skills | [askill](https://github.com/amanasmuei/askill) | Domain expertise with leveling (testing, security, etc.) |
 | 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** |
+| Channels | [achannel](https://github.com/amanasmuei/achannel) | Telegram, Discord, webhook server |
+| Runtime | [aman-agent](https://github.com/amanasmuei/aman-agent) | Standalone AI companion CLI |
+| **Unified** | **[aman](https://github.com/amanasmuei/aman)** | **Setup + Deploy — one command for everything** |
 
 Each package works independently. `aman` is the front door.
 
@@ -75,7 +81,8 @@ 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 6 layers) |
+| `aman status` | View ecosystem status (all layers) |
+| `aman deploy` | Deploy your AI anywhere (Docker, Ollama, systemd) |
 
 After setup, use the individual CLIs for detailed management:
 
@@ -114,6 +121,65 @@ $ aman status
 
 ---
 
+## Deploy Anywhere
+
+Make your AI companion always-on — accessible from terminal, browser, Telegram, or Discord.
+
+```bash
+npx @aman_asmuei/aman deploy
+```
+
+Interactive wizard with 4 deployment methods:
+
+### Docker Compose (VPS / Home Server)
+
+```bash
+aman deploy          # select "Docker Compose", enter API key
+docker compose up -d # → running on port 3000
+```
+
+Packages the full ecosystem in one container: aman-agent + achannel (Telegram/Discord/webhook) + aman-mcp + amem.
+
+### Docker + Ollama (Fully Local)
+
+```bash
+aman deploy          # select "Docker + Ollama"
+docker compose up -d # → aman + Ollama, zero cloud dependency
+```
+
+No API key needed. Runs on Raspberry Pi 4/5 (ARM64), any Linux, macOS.
+
+### Systemd Service (Bare Metal / Raspberry Pi)
+
+```bash
+aman deploy          # select "Systemd service"
+# Shows step-by-step install for bare metal Linux
+```
+
+### What's in the Docker Image
+
+| Component | What it does |
+|:---|:---|
+| **aman-agent** | Interactive CLI companion |
+| **achannel** | Telegram, Discord, webhook server |
+| **aman-mcp** | MCP bridge for all ecosystem layers |
+| **amem** | Persistent memory with SQLite |
+
+### Environment Variables
+
+| Variable | Description |
+|:---|:---|
+| `ANTHROPIC_API_KEY` | Anthropic API key |
+| `OPENAI_API_KEY` | OpenAI API key (alternative) |
+| `AMAN_AI_NAME` | Your AI's name (default: Aman) |
+| `AMAN_MODEL` | LLM model (default: claude-sonnet-4-6) |
+| `TELEGRAM_BOT_TOKEN` | Optional — Telegram bot |
+| `DISCORD_BOT_TOKEN` | Optional — Discord bot |
+
+All data persists in Docker volumes (identity, memory, config, rules, workflows, skills, eval).
+
+---
+
 ## How It All Connects
 
 Every layer is a markdown file. acore auto-injects all of them into your AI's system prompt:
@@ -151,6 +217,6 @@ ChatGPT, Claude, Claude Code, Cursor, Windsurf, Gemini, Ollama, and any AI that
 
 <div align="center">
 
-**One command. 6 layers. Any AI. Your companion.**
+**Setup. Deploy. Run anywhere. Your AI companion.**
 
 </div>

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 {
     }
@@ -628,9 +628,217 @@ function statusCommand() {
   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.2.0").action(() => {
+program.name("aman").description("Your complete AI companion \u2014 identity, memory, and tools in one command").version("0.3.1").action(() => {
   const ecosystem = detectEcosystem();
   if (ecosystem.acore.installed) {
     statusCommand();
@@ -640,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.2.0",
+  "version": "0.3.1",
   "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",