@nguyentamdat/mempalace 1.0.0

package/README.md

@@ -0,0 +1,127 @@
+# mempalace
+
+Give your AI a memory. No API key required.
+
+A structured, persistent memory system for AI agents — featuring a palace metaphor (wings → rooms → drawers), a temporal knowledge graph, the AAAK compression dialect, and a 4-layer memory stack.
+
+This is a **Bun/TypeScript** port of the original [mempalace](https://github.com/milla-jovovich/mempalace) by [milla-jovovich](https://github.com/milla-jovovich).
+
+## Requirements
+
+- [Bun](https://bun.sh/) ≥ 1.0
+- [ChromaDB](https://www.trychroma.com/) server running (`chroma run`)
+
+## Install
+
+```bash
+git clone https://github.com/nguyentamdat/mempalace-js.git
+cd mempalace-js
+bun install
+```
+
+## Usage
+
+### CLI
+
+```bash
+# Initialize a new palace
+bun run src/index.ts init
+
+# Mine project files into the palace
+bun run src/index.ts mine --mode projects --path ./my-project
+
+# Mine conversation transcripts
+bun run src/index.ts mine --mode convos --path ./transcripts
+
+# Search memories
+bun run src/index.ts search "some query"
+
+# Compress memories with AAAK dialect
+bun run src/index.ts compress
+
+# Load memory layers (wake-up)
+bun run src/index.ts wake-up
+
+# Split mega transcript files
+bun run src/index.ts split --path ./mega-file.txt
+
+# Palace status
+bun run src/index.ts status
+```
+
+### MCP Server
+
+Run as a JSON-RPC MCP server over stdin/stdout (19 tools):
+
+```bash
+bun run src/mcp-server.ts
+```
+
+Tools include: `mempalace_search`, `mempalace_kg_query`, `mempalace_kg_timeline`, `mempalace_kg_add`, `mempalace_kg_invalidate`, `mempalace_diary_write`, `mempalace_diary_read`, `mempalace_status`, `mempalace_list_wings`, `mempalace_list_rooms`, `mempalace_add_drawer`, `mempalace_delete_drawer`, `mempalace_traverse`, `mempalace_find_tunnels`, and more.
+
+## Architecture
+
+### Palace Structure
+
+```
+Palace (~/.mempalace/)
+├── Wings (top-level categories: work, personal, health, etc.)
+│   └── Rooms (specific topics within a wing)
+│       └── Drawers (individual memories stored in ChromaDB)
+├── Knowledge Graph (SQLite — entities + temporal triples)
+├── Diary (daily entries)
+└── Config (config.json, entity_registry.json, identity.txt)
+```
+
+### Memory Layers
+
+| Layer | Content | Size |
+|-------|---------|------|
+| Layer 0 | `identity.txt` — who am I | ~100 tokens |
+| Layer 1 | Auto-generated from top drawers | ~500-800 tokens |
+| Layer 2 | On-demand wing/room filtered | Variable |
+| Layer 3 | Deep semantic search | Variable |
+
+### AAAK Compression Dialect
+
+A compact encoding format for memories that reduces token usage while preserving meaning. Includes emotion codes, flag signals, and stop-word removal.
+
+### Knowledge Graph
+
+SQLite-based temporal entity-relationship graph with validity windows and confidence scores. Supports entities (people, projects, concepts) and triples (subject → predicate → object).
+
+## Modules
+
+| Module | Description |
+|--------|-------------|
+| `config.ts` | Palace configuration management |
+| `knowledge-graph.ts` | Temporal entity-relationship graph (bun:sqlite) |
+| `dialect.ts` | AAAK compression dialect |
+| `layers.ts` | 4-layer memory stack |
+| `searcher.ts` | Semantic search via ChromaDB |
+| `palace-graph.ts` | Graph traversal and tunnel detection |
+| `miner.ts` | Project file mining |
+| `convo-miner.ts` | Conversation mining |
+| `normalize.ts` | Chat export normalization (Claude, ChatGPT, Slack) |
+| `general-extractor.ts` | Extract decisions, preferences, milestones |
+| `entity-registry.ts` | Persistent entity registry with Wikipedia lookup |
+| `entity-detector.ts` | Auto-detect people/projects from text |
+| `onboarding.ts` | Interactive setup wizard |
+| `room-detector-local.ts` | Room detection from folder structure |
+| `spellcheck.ts` | Optional spell correction |
+| `split-mega-files.ts` | Split concatenated transcripts |
+| `mcp-server.ts` | JSON-RPC MCP server (19 tools) |
+
+## Tests
+
+```bash
+bun test
+```
+
+## Acknowledgements
+
+This project is a Bun/TypeScript port of the original [mempalace](https://github.com/milla-jovovich/mempalace) by [milla-jovovich](https://github.com/milla-jovovich). All credit for the palace architecture, AAAK compression dialect, knowledge graph design, memory layer system, and MCP tool definitions goes to their work.
+
+## License
+
+MIT

package/hooks/README.md

@@ -0,0 +1,133 @@
+# MemPalace Hooks — Auto-Save for Terminal AI Tools
+
+These hook scripts make MemPalace save automatically. No manual "save" commands needed.
+
+## What They Do
+
+| Hook | When It Fires | What Happens |
+|------|--------------|-------------|
+| **Save Hook** | Every 15 human messages | Blocks the AI, tells it to save key topics/decisions/quotes to the palace |
+| **PreCompact Hook** | Right before context compaction | Emergency save — forces the AI to save EVERYTHING before losing context |
+
+The AI does the actual filing — it knows the conversation context, so it classifies memories into the right wings/halls/closets. The hooks just tell it WHEN to save.
+
+## Install — Bun repo setup
+
+From the repo root:
+
+```bash
+bun install
+chmod +x hooks/mempal_save_hook.sh hooks/mempal_precompact_hook.sh
+```
+
+## Install — Claude Code
+
+Add to `.claude/settings.local.json`:
+
+```json
+{
+  "hooks": {
+    "Stop": [{
+      "matcher": "*",
+      "hooks": [{
+        "type": "command",
+        "command": "/absolute/path/to/hooks/mempal_save_hook.sh",
+        "timeout": 30
+      }]
+    }],
+    "PreCompact": [{
+      "hooks": [{
+        "type": "command",
+        "command": "/absolute/path/to/hooks/mempal_precompact_hook.sh",
+        "timeout": 30
+      }]
+    }]
+  }
+}
+```
+
+## Install — OpenCode
+
+Configure the same shell scripts as your `Stop` and `PreCompact` command hooks in OpenCode, pointing to:
+
+- `/absolute/path/to/hooks/mempal_save_hook.sh`
+- `/absolute/path/to/hooks/mempal_precompact_hook.sh`
+
+The scripts are standalone bash hooks and auto-resolve the Bun repo root from their own location.
+
+## Configuration
+
+Edit `mempal_save_hook.sh` to change:
+
+- **`SAVE_INTERVAL=15`** — How many human messages between saves. Lower = more frequent saves, higher = less interruption.
+- **`STATE_DIR`** — Where hook state is stored (defaults to `~/.mempalace/hook_state/`)
+- **`MEMPAL_DIR`** — Optional. Set to a conversations directory to auto-run `bun run src/index.ts mine <dir>` on each save trigger. Leave blank (default) to let the AI handle saving via the block reason message.
+
+### mempalace CLI
+
+The relevant commands are:
+
+```bash
+bun run src/index.ts mine <dir>                # Mine all files in a directory
+bun run src/index.ts mine <dir> --mode convos  # Mine conversation transcripts only
+```
+
+The hooks resolve the repo root automatically from their own path, so they work regardless of where you install the repo.
+
+## How It Works (Technical)
+
+### Save Hook (Stop event)
+
+```
+User sends message → AI responds → Claude Code / OpenCode fires Stop hook
+                                                     ↓
+                                             Hook counts human messages in JSONL transcript
+                                                     ↓
+                               ┌─── < 15 since last save ──→ echo "{}" (let AI stop)
+                               │
+                               └─── ≥ 15 since last save ──→ {"decision": "block", "reason": "save..."}
+                                                                             ↓
+                                                                     AI saves to palace
+                                                                             ↓
+                                                                     AI tries to stop again
+                                                                             ↓
+                                                                     stop_hook_active = true
+                                                                             ↓
+                                                                     Hook sees flag → echo "{}" (let it through)
+```
+
+The `stop_hook_active` flag prevents infinite loops: block once → AI saves → tries to stop → flag is true → we let it through.
+
+### PreCompact Hook
+
+```
+Context window getting full → Claude Code / OpenCode fires PreCompact
+                                                 ↓
+                                         Hook ALWAYS blocks
+                                                 ↓
+                                         AI saves everything
+                                                 ↓
+                                         Compaction proceeds
+```
+
+No counting needed — compaction always warrants a save.
+
+## Debugging
+
+Check the hook log:
+
+```bash
+cat ~/.mempalace/hook_state/hook.log
+```
+
+Example output:
+```
+[14:30:15] Session abc123: 12 exchanges, 12 since last save
+[14:35:22] Session abc123: 15 exchanges, 15 since last save
+[14:35:22] TRIGGERING SAVE at exchange 15
+[14:40:01] Session abc123: 18 exchanges, 3 since last save
+```
+
+## Cost
+
+**Zero extra tokens.** The hooks are bash scripts that run locally. They don't call any API. The only "cost" is the AI spending a few seconds organizing memories at each checkpoint — and it's doing that with context it already has loaded.

package/hooks/mempal_precompact_hook.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+STATE_DIR="$HOME/.mempalace/hook_state"
+mkdir -p "$STATE_DIR"
+
+MEMPAL_DIR=""
+
+INPUT=$(cat)
+
+json_get() {
+    local key="$1"
+
+    if command -v jq >/dev/null 2>&1; then
+        printf '%s' "$INPUT" | jq -r --arg key "$key" '.[$key] // empty' 2>/dev/null
+    elif command -v node >/dev/null 2>&1; then
+        printf '%s' "$INPUT" | node -e 'const fs = require("fs"); const key = process.argv[1]; try { const data = JSON.parse(fs.readFileSync(0, "utf8")); const value = data?.[key]; if (value !== undefined && value !== null) process.stdout.write(String(value)); } catch {}' "$key" 2>/dev/null
+    fi
+}
+
+SESSION_ID=$(json_get "session_id")
+SESSION_ID=${SESSION_ID:-unknown}
+
+echo "[$(date '+%H:%M:%S')] PRE-COMPACT triggered for session $SESSION_ID" >> "$STATE_DIR/hook.log"
+
+if [ -n "$MEMPAL_DIR" ] && [ -d "$MEMPAL_DIR" ]; then
+    SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+    REPO_DIR="$(dirname "$SCRIPT_DIR")"
+    bun run "$REPO_DIR/src/index.ts" mine "$MEMPAL_DIR" >> "$STATE_DIR/hook.log" 2>&1
+fi
+
+cat << 'HOOKJSON'
+{
+  "decision": "block",
+  "reason": "COMPACTION IMMINENT. Save ALL topics, decisions, quotes, code, and important context from this session to your memory system. Be thorough — after compaction, detailed context will be lost. Organize into appropriate categories. Use verbatim quotes where possible. Save everything, then allow compaction to proceed."
+}
+HOOKJSON

package/hooks/mempal_save_hook.sh

@@ -0,0 +1,80 @@
+#!/bin/bash
+SAVE_INTERVAL=15
+STATE_DIR="$HOME/.mempalace/hook_state"
+mkdir -p "$STATE_DIR"
+
+MEMPAL_DIR=""
+
+INPUT=$(cat)
+
+json_get() {
+    local key="$1"
+
+    if command -v jq >/dev/null 2>&1; then
+        printf '%s' "$INPUT" | jq -r --arg key "$key" '.[$key] // empty' 2>/dev/null
+    elif command -v node >/dev/null 2>&1; then
+        printf '%s' "$INPUT" | node -e 'const fs = require("fs"); const key = process.argv[1]; try { const data = JSON.parse(fs.readFileSync(0, "utf8")); const value = data?.[key]; if (value !== undefined && value !== null) process.stdout.write(String(value)); } catch {}' "$key" 2>/dev/null
+    fi
+}
+
+count_user_messages() {
+    if command -v jq >/dev/null 2>&1; then
+        jq -Rnc '[inputs | (try fromjson catch empty) | .message | select(type == "object" and .role == "user" and ((.content | type) != "string" or (.content | contains("<command-message>") | not)))] | length' "$TRANSCRIPT_PATH" 2>/dev/null
+    elif command -v node >/dev/null 2>&1; then
+        node -e 'const fs = require("fs"); const path = process.argv[1]; let count = 0; try { for (const line of fs.readFileSync(path, "utf8").split(/\r?\n/)) { if (!line.trim()) continue; try { const entry = JSON.parse(line); const msg = entry?.message; if (msg && typeof msg === "object" && msg.role === "user") { const content = msg.content; if (typeof content === "string" && content.includes("<command-message>")) continue; count += 1; } } catch {} } } catch {} process.stdout.write(String(count));' "$TRANSCRIPT_PATH" 2>/dev/null
+    fi
+}
+
+SESSION_ID=$(json_get "session_id")
+SESSION_ID=${SESSION_ID:-unknown}
+
+STOP_HOOK_ACTIVE=$(json_get "stop_hook_active")
+STOP_HOOK_ACTIVE=${STOP_HOOK_ACTIVE:-false}
+
+TRANSCRIPT_PATH=$(json_get "transcript_path")
+TRANSCRIPT_PATH=${TRANSCRIPT_PATH:-}
+
+TRANSCRIPT_PATH="${TRANSCRIPT_PATH/#\~/$HOME}"
+
+if [ "$STOP_HOOK_ACTIVE" = "True" ] || [ "$STOP_HOOK_ACTIVE" = "true" ]; then
+    echo "{}"
+    exit 0
+fi
+
+if [ -f "$TRANSCRIPT_PATH" ]; then
+    EXCHANGE_COUNT=$(count_user_messages)
+    EXCHANGE_COUNT=${EXCHANGE_COUNT:-0}
+else
+    EXCHANGE_COUNT=0
+fi
+
+LAST_SAVE_FILE="$STATE_DIR/${SESSION_ID}_last_save"
+LAST_SAVE=0
+if [ -f "$LAST_SAVE_FILE" ]; then
+    LAST_SAVE=$(cat "$LAST_SAVE_FILE")
+fi
+
+SINCE_LAST=$((EXCHANGE_COUNT - LAST_SAVE))
+
+echo "[$(date '+%H:%M:%S')] Session $SESSION_ID: $EXCHANGE_COUNT exchanges, $SINCE_LAST since last save" >> "$STATE_DIR/hook.log"
+
+if [ "$SINCE_LAST" -ge "$SAVE_INTERVAL" ] && [ "$EXCHANGE_COUNT" -gt 0 ]; then
+    echo "$EXCHANGE_COUNT" > "$LAST_SAVE_FILE"
+
+    echo "[$(date '+%H:%M:%S')] TRIGGERING SAVE at exchange $EXCHANGE_COUNT" >> "$STATE_DIR/hook.log"
+
+    if [ -n "$MEMPAL_DIR" ] && [ -d "$MEMPAL_DIR" ]; then
+        SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+        REPO_DIR="$(dirname "$SCRIPT_DIR")"
+        bun run "$REPO_DIR/src/index.ts" mine "$MEMPAL_DIR" >> "$STATE_DIR/hook.log" 2>&1 &
+    fi
+
+    cat << 'HOOKJSON'
+{
+  "decision": "block",
+  "reason": "AUTO-SAVE checkpoint. Save key topics, decisions, quotes, and code from this session to your memory system. Organize into appropriate categories. Use verbatim quotes where possible. Continue conversation after saving."
+}
+HOOKJSON
+else
+    echo "{}"
+fi

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@nguyentamdat/mempalace",
+  "version": "1.0.0",
+  "description": "Give your AI a memory. No API key required.",
+  "type": "module",
+  "bin": {
+    "mempalace": "./src/index.ts"
+  },
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "check": "bunx tsc --noEmit",
+    "test": "bun test",
+    "mcp": "bun run src/mcp-server.ts"
+  },
+  "dependencies": {
+    "chromadb": "^1.9.2",
+    "citty": "^0.1.6",
+    "js-yaml": "^4.1.0",
+    "@clack/prompts": "^0.9.1"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/bun": "latest"
+  },
+  "license": "MIT",
+  "author": "nguyentamdat",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nguyentamdat/mempalace-js"
+  },
+  "files": [
+    "src",
+    "hooks",
+    "README.md"
+  ]
+}

package/src/cli.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env bun
+/**
+ * MemPalace — Give your AI a memory. No API key required.
+ *
+ * Two ways to ingest:
+ *   Projects:      mempalace mine ~/projects/my_app          (code, docs, notes)
+ *   Conversations: mempalace mine ~/chats/ --mode convos     (Claude, ChatGPT, Slack)
+ *
+ * Commands:
+ *   mempalace init <dir>                  Detect rooms from folder structure
+ *   mempalace split <dir>                 Split concatenated mega-files
+ *   mempalace mine <dir>                  Mine project files (default)
+ *   mempalace mine <dir> --mode convos    Mine conversation exports
+ *   mempalace search "query"              Find anything, exact words
+ *   mempalace wake-up                     Show L0 + L1 wake-up context
+ *   mempalace status                      Show what's been filed
+ */
+
+import { defineCommand, runMain } from "citty";
+import { MempalaceConfig } from "./config";
+
+const mainCommand = defineCommand({
+  meta: {
+    name: "mempalace",
+    version: "1.0.0",
+    description: "Give your AI a memory. No API key required.",
+  },
+  args: {
+    palace: {
+      type: "string",
+      description: "Where the palace lives (default: from config or ~/.mempalace/palace)",
+    },
+  },
+  subCommands: {
+    init: () => import("./commands/init").then((m) => m.default),
+    mine: () => import("./commands/mine").then((m) => m.default),
+    search: () => import("./commands/search").then((m) => m.default),
+    compress: () => import("./commands/compress").then((m) => m.default),
+    "wake-up": () => import("./commands/wake-up").then((m) => m.default),
+    split: () => import("./commands/split").then((m) => m.default),
+    status: () => import("./commands/status").then((m) => m.default),
+  },
+});
+
+export function resolvePalacePath(palaceArg?: string): string {
+  if (palaceArg) return palaceArg.replace(/^~/, process.env.HOME ?? "~");
+  return new MempalaceConfig().palacePath;
+}
+
+export default mainCommand;

package/src/commands/compress.ts

@@ -0,0 +1,161 @@
+import { defineCommand } from "citty";
+import { resolvePalacePath } from "../cli";
+
+export default defineCommand({
+  meta: { description: "Compress drawers using AAAK Dialect (~30x reduction)" },
+  args: {
+    wing: { type: "string", description: "Wing to compress (default: all wings)" },
+    "dry-run": { type: "boolean", description: "Preview compression without storing", default: false },
+    config: { type: "string", description: "Entity config JSON (e.g. entities.json)" },
+  },
+  async run({ args }) {
+    const { existsSync } = await import("node:fs");
+    const { join, basename } = await import("node:path");
+    const { ChromaClient, DefaultEmbeddingFunction, IncludeEnum } = await import("chromadb");
+    const { Dialect } = await import("../dialect");
+
+    const palacePath = resolvePalacePath(args.palace as string | undefined);
+    const dryRun = args["dry-run"];
+
+    // Load dialect (with optional entity config)
+    let configPath = args.config;
+    if (!configPath) {
+      for (const candidate of ["entities.json", join(palacePath, "entities.json")]) {
+        if (existsSync(candidate)) {
+          configPath = candidate;
+          break;
+        }
+      }
+    }
+
+    let dialect: InstanceType<typeof Dialect>;
+    if (configPath && existsSync(configPath)) {
+      dialect = Dialect.fromConfig(configPath);
+      console.log(`  Loaded entity config: ${configPath}`);
+    } else {
+      dialect = new Dialect();
+    }
+
+    // Connect to palace
+    let client: InstanceType<typeof ChromaClient>;
+    let col: Awaited<ReturnType<InstanceType<typeof ChromaClient>["getCollection"]>>;
+    try {
+      client = new ChromaClient({ path: palacePath });
+      col = await client.getCollection({
+        name: "mempalace_drawers",
+        embeddingFunction: new DefaultEmbeddingFunction(),
+      });
+    } catch {
+      console.log(`\n  No palace found at ${palacePath}`);
+      console.log("  Run: mempalace init <dir> then mempalace mine <dir>");
+      process.exit(1);
+    }
+
+    // Query drawers in the wing
+    const where = args.wing ? { wing: args.wing } : undefined;
+    let results: Awaited<ReturnType<typeof col.get>>;
+    try {
+      results = await col.get({
+        where,
+        include: [IncludeEnum.Documents, IncludeEnum.Metadatas],
+      });
+    } catch (e) {
+      console.log(`\n  Error reading drawers: ${e}`);
+      process.exit(1);
+    }
+
+    const docs = results.documents ?? [];
+    const metas = results.metadatas ?? [];
+    const ids = results.ids;
+
+    if (docs.length === 0) {
+      const wingLabel = args.wing ? ` in wing '${args.wing}'` : "";
+      console.log(`\n  No drawers found${wingLabel}.`);
+      return;
+    }
+
+    console.log(
+      `\n  Compressing ${docs.length} drawers` +
+        (args.wing ? ` in wing '${args.wing}'` : "") +
+        "..."
+    );
+    console.log();
+
+    let totalOriginal = 0;
+    let totalCompressed = 0;
+    const compressedEntries: Array<{
+      id: string;
+      compressed: string;
+      meta: Record<string, unknown>;
+      stats: ReturnType<typeof Dialect.prototype.compressionStats>;
+    }> = [];
+
+    for (let i = 0; i < docs.length; i++) {
+      const doc = docs[i];
+      if (doc === null || doc === undefined) {
+        continue;
+      }
+
+      const meta = (metas[i] ?? {}) as Record<string, unknown>;
+      const docId = ids[i];
+
+      const compressed = dialect.compress(doc, meta);
+      const stats = dialect.compressionStats(doc, compressed);
+
+      totalOriginal += stats.originalChars;
+      totalCompressed += stats.compressedChars;
+      compressedEntries.push({ id: docId, compressed, meta, stats });
+
+      if (dryRun) {
+        const wingName = (meta.wing as string) ?? "?";
+        const roomName = (meta.room as string) ?? "?";
+        const source = basename((meta.source_file as string) ?? "?");
+        console.log(`  [${wingName}/${roomName}] ${source}`);
+        console.log(
+          `    ${stats.originalTokens}t -> ${stats.compressedTokens}t (${stats.ratio.toFixed(1)}x)`
+        );
+        console.log(`    ${compressed}`);
+        console.log();
+      }
+    }
+
+    // Store compressed versions (unless dry-run)
+    if (!dryRun) {
+      try {
+        const compCol = await client.getOrCreateCollection({
+          name: "mempalace_compressed",
+          embeddingFunction: new DefaultEmbeddingFunction(),
+        });
+        for (const { id, compressed, meta, stats } of compressedEntries) {
+          const compMeta = {
+            ...meta,
+            compression_ratio: Math.round(stats.ratio * 10) / 10,
+            original_tokens: stats.originalTokens,
+          };
+          await compCol.upsert({
+            ids: [id],
+            documents: [compressed],
+            metadatas: [compMeta as Record<string, string | number | boolean>],
+          });
+        }
+        console.log(
+          `  Stored ${compressedEntries.length} compressed drawers in 'mempalace_compressed' collection.`
+        );
+      } catch (e) {
+        console.log(`  Error storing compressed drawers: ${e}`);
+        process.exit(1);
+      }
+    }
+
+    // Summary
+    const ratio = totalOriginal / Math.max(totalCompressed, 1);
+    const origTokens = Dialect.countTokens("x".repeat(totalOriginal));
+    const compTokens = Dialect.countTokens("x".repeat(totalCompressed));
+    console.log(
+      `  Total: ${origTokens.toLocaleString()}t -> ${compTokens.toLocaleString()}t (${ratio.toFixed(1)}x compression)`
+    );
+    if (dryRun) {
+      console.log("  (dry run -- nothing stored)");
+    }
+  },
+});

package/src/commands/init.ts

@@ -0,0 +1,40 @@
+import { defineCommand } from "citty";
+import { MempalaceConfig } from "../config";
+
+export default defineCommand({
+  meta: { description: "Detect rooms from your folder structure" },
+  args: {
+    dir: { type: "positional", description: "Project directory to set up", required: true },
+    yes: { type: "boolean", description: "Auto-accept all detected entities", default: false },
+  },
+  async run({ args }) {
+    const { scanForDetection, detectEntities, confirmEntities } = await import("../entity-detector");
+    const { detectRoomsLocal } = await import("../room-detector");
+    const { writeFileSync } = await import("fs");
+    const { resolve } = await import("path");
+
+    // Pass 1: auto-detect people and projects from file content
+    console.log(`\n  Scanning for entities in: ${args.dir}`);
+    const files = scanForDetection(args.dir);
+    if (files.length > 0) {
+      console.log(`  Reading ${files.length} files...`);
+      const detected = detectEntities(files);
+      const total =
+        detected.people.length + detected.projects.length + detected.uncertain.length;
+      if (total > 0) {
+        const confirmed = await confirmEntities(detected, args.yes);
+        if (confirmed.people.length > 0 || confirmed.projects.length > 0) {
+          const entitiesPath = resolve(args.dir, "entities.json");
+          writeFileSync(entitiesPath, JSON.stringify(confirmed, null, 2));
+          console.log(`  Entities saved: ${entitiesPath}`);
+        }
+      } else {
+        console.log("  No entities detected — proceeding with directory-based rooms.");
+      }
+    }
+
+    // Pass 2: detect rooms from folder structure
+    await detectRoomsLocal(args.dir);
+    new MempalaceConfig().init();
+  },
+});