refactor(workspace): migrate to hexagonal architecture, add alice-cli, adapters, and core

Author: Akagi201

Cargo.toml

@@ -2,7 +2,7 @@
 version = "0.1.0"
 edition = "2024"
 license = "Apache-2.0"
-repository = "TODO"
+repository = "https://github.com/longcipher/alice"
 
 [workspace]
 members = ["bin/*", "crates/*"]
@@ -11,9 +11,9 @@ resolver = "3"
 
 [workspace.dependencies]
 async-trait = "0.1.89"
-bob-adapters = "0.1.2"
-bob-core = "0.1.2"
-bob-runtime = "0.1.2"
+bob-adapters = "0.2.0"
+bob-core = "0.2.0"
+bob-runtime = "0.2.0"
 clap = "4.5.60"
 config = "0.15.19"
 eyre = "0.6.12"

README.md

@@ -5,17 +5,21 @@ Alice is a minimal, reusable AI agent application built with a hexagonal archite
 ## What Alice Includes
 
 - Bob runtime orchestration (`bob-core`, `bob-runtime`, `bob-adapters`)
-- CLI interaction (`alice` command behavior in `bin/cli-app`)
-- Local memory system in `crates/common` with:
+- Hexagonal architecture with clean layer boundaries
+- Skill system integration — auto-selects relevant `SKILL.md` files per turn
+- Multi-channel adapters: CLI REPL, Discord, and Telegram
+- Local memory system with:
   - SQLite persistence
   - FTS5 full-text recall
   - sqlite-vec vector search
   - hybrid ranking (BM25 + vector similarity)
 
 ## Workspace Layout
 
-- `bin/cli-app`: Alice CLI composition root
-- `crates/common`: shared memory domain/service/SQLite adapter
+- `bin/alice-cli`: thin CLI binary — clap parsing and dispatch
+- `crates/alice-core`: innermost layer — domain types, port traits, service logic (zero adapter deps)
+- `crates/alice-adapters`: concrete implementations — SQLite memory store, CLI/Discord/Telegram channel adapters
+- `crates/alice-runtime`: composition root — config, bootstrap, commands, skill wiring, channel runner
 - `specs/`: design and task specs
 
 ## Quick Start
@@ -29,21 +33,71 @@ just format
 just lint
 just test
 
-# Run Alice (interactive)
-cargo run -p cli-app -- --config alice.toml
+# Run Alice (interactive chat)
+cargo run -p alice-cli -- --config alice.toml chat
 
 # Run one prompt and exit
-cargo run -p cli-app -- --config alice.toml --once "summarize our current memory setup"
+cargo run -p alice-cli -- --config alice.toml run "summarize our current memory setup"
+
+# Run with multi-channel support (CLI + enabled adapters)
+cargo run -p alice-cli -- --config alice.toml channel
 ```
 
 ## Configuration
 
 Use `alice.toml` in repo root as a starting point. Key sections:
 
-- `[runtime]`: model and turn limits
+- `[runtime]`: model, turn limits, dispatch mode
 - `[memory]`: sqlite path and hybrid recall weights
+- `[skills]`: skill system — enable/disable, source directories, token budget
+- `[channels.discord]` / `[channels.telegram]`: channel adapters (require env vars)
 - `[[mcp.servers]]`: optional MCP tool servers
 
-## Current Scope
+### Skills
+
+Place `SKILL.md` files in a directory and configure the path in `alice.toml`:
+
+```toml
+[skills]
+enabled = true
+max_selected = 3
+token_budget = 1800
+
+[[skills.sources]]
+path = "./skills"
+recursive = true
+```
+
+### Channels
+
+Enable Discord and/or Telegram alongside the default CLI REPL:
+
+```toml
+[channels.discord]
+enabled = true
+
+[channels.telegram]
+enabled = true
+```
+
+Set the corresponding environment variables:
+
+```bash
+export ALICE_DISCORD_TOKEN="your-discord-bot-token"
+export ALICE_TELEGRAM_TOKEN="your-telegram-bot-token"
+```
+
+## Building with Channel Features
 
-Alice is intentionally CLI-first and local-first. Web gateways, multi-channel bots, and distributed memory are out of scope for this phase.
+Discord and Telegram adapters are behind feature flags:
+
+```bash
+# Build with Discord support
+cargo build -p alice-cli --features discord
+
+# Build with Telegram support
+cargo build -p alice-cli --features telegram
+
+# Build with both
+cargo build -p alice-cli --features discord,telegram
+```

alice.toml

@@ -12,7 +12,28 @@ vector_weight = 0.7
 vector_dimensions = 384
 enable_vector = true
 
-# Optional MCP servers
+# Skill system configuration — auto-selects relevant SKILL.md files per turn.
+# [skills]
+# enabled = true
+# max_selected = 3
+# token_budget = 1800
+#
+# [[skills.sources]]
+# path = "./skills"
+# recursive = true
+
+# Channel adapters — enable multi-channel input beyond the default CLI REPL.
+# Discord requires ALICE_DISCORD_TOKEN env var.
+# Telegram requires ALICE_TELEGRAM_TOKEN env var.
+# [channels.discord]
+# enabled = false
+# [channels.telegram]
+# enabled = false
+
+# Built-in tools (local/file_read, local/file_write, local/file_list,
+# local/shell_exec) are always available. Additional MCP servers can be
+# configured below.
+
 # [[mcp.servers]]
 # id = "filesystem"
 # command = "npx"

bin/alice-cli/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "alice-cli"
+version.workspace = true
+edition.workspace = true
+
+[[bin]]
+name = "alice"
+path = "src/main.rs"
+
+[dependencies]
+alice-runtime = { path = "../../crates/alice-runtime" }
+clap = { workspace = true, features = ["derive"] }
+eyre.workspace = true
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
+tracing-subscriber.workspace = true
+
+[dev-dependencies]
+alice-adapters = { path = "../../crates/alice-adapters" }
+alice-core = { path = "../../crates/alice-core" }
+async-trait.workspace = true
+bob-adapters.workspace = true
+bob-core.workspace = true
+bob-runtime.workspace = true
+parking_lot.workspace = true
+
+[lints]
+workspace = true

bin/alice-cli/src/main.rs

@@ -0,0 +1,68 @@
+//! Alice CLI binary.
+//!
+//! Supports three modes:
+//! - `run`  — one-shot prompt execution
+//! - `chat` — interactive REPL with slash command routing
+//! - `channel` — message channel runtime (Telegram, Discord, etc.)
+
+use std::sync::Arc;
+
+use clap::{Parser, Subcommand};
+
+/// Alice — a collaborative AI agent built on the Bob framework.
+#[derive(Debug, Parser)]
+#[command(name = "alice", version, about = "Alice CLI agent")]
+struct Cli {
+    /// Path to configuration file.
+    #[arg(short, long, default_value = "alice.toml", global = true)]
+    config: String,
+
+    #[command(subcommand)]
+    command: Option<Commands>,
+}
+
+#[derive(Debug, Subcommand)]
+enum Commands {
+    /// Run a single prompt and exit.
+    Run {
+        /// The prompt to execute.
+        prompt: String,
+
+        /// Session identifier for memory continuity.
+        #[arg(long, default_value = "alice-once")]
+        session_id: String,
+    },
+
+    /// Start an interactive REPL session.
+    Chat {
+        /// Session identifier for memory continuity.
+        #[arg(long, default_value = "alice-session")]
+        session_id: String,
+    },
+
+    /// Run enabled message channels (Telegram, Discord, etc.).
+    Channel,
+}
+
+#[tokio::main]
+async fn main() -> eyre::Result<()> {
+    tracing_subscriber::fmt().with_target(false).init();
+
+    let cli = Cli::parse();
+    let cfg = alice_runtime::config::load_config(&cli.config)?;
+    let context = Arc::new(alice_runtime::bootstrap::build_runtime(&cfg).await?);
+
+    match cli.command {
+        Some(Commands::Run { prompt, session_id }) => {
+            alice_runtime::commands::cmd_run(&context, &session_id, &prompt).await
+        }
+        Some(Commands::Chat { session_id }) => {
+            alice_runtime::commands::cmd_chat(Arc::clone(&context), &session_id).await
+        }
+        Some(Commands::Channel) => {
+            alice_runtime::commands::cmd_channel(Arc::clone(&context), &cfg.channels).await
+        }
+        // Default to chat when no subcommand is given.
+        None => alice_runtime::commands::cmd_chat(Arc::clone(&context), "alice-session").await,
+    }
+}