get-claudia 1.2.5 → 1.2.7

package/README.md

@@ -43,39 +43,36 @@ Say hi. She'll introduce herself and set things up for you.
 
 ---
 
+## What's New in v1.2.5
+
+**Fully automatic memory system** - No more manual steps after install:
+
+- **Works after reboot** - Ollama and the memory daemon auto-start on login (macOS LaunchAgent)
+- **Python 3.13 support** - sqlite-vec now works on all Python versions
+- **Boot resilience** - Daemon waits for Ollama to start instead of failing silently
+- **Better diagnostics** - Run `~/.claudia/diagnose.sh` to check all services
+
+The memory system just works now. Install, reboot, and everything comes back up.
+
+---
+
 ## Already Have Claudia? Add Memory.
 
-If you installed Claudia before the memory system existed, you can upgrade:
+If you installed Claudia before the memory system existed, just run the installer again:
 
 ```bash
-# Clone the repo (or pull latest if you have it)
-git clone https://github.com/kbanc/claudia.git
-cd claudia/memory-daemon
-
-# Run the installer
-./scripts/install.sh
+npx get-claudia
 ```
 
-The installer will:
+When prompted, say **yes** to install the memory system. The installer will:
 - Set up the memory daemon at `~/.claudia/daemon/`
-- Install Ollama for local embeddings (optional but recommended)
-- Configure auto-start so the daemon runs on login
-- Show you what to add to your `.mcp.json`
-
-After installing, add this to your Claudia project's `.mcp.json`:
-
-```json
-{
-  "mcpServers": {
-    "claudia-memory": {
-      "command": "~/.claudia/daemon/venv/bin/python",
-      "args": ["-m", "claudia_memory.mcp.server"]
-    }
-  }
-}
-```
+- Install Ollama for semantic search (optional but recommended)
+- Configure auto-start so everything runs on login
+- Pull the embedding model automatically
+- Verify all services are working
+- Update your `.mcp.json` automatically
 
-Restart Claude Code, and Claudia now has persistent memory.
+Restart Claude Code in a new terminal, and Claudia now has persistent memory.
 
 ---
 
@@ -83,11 +80,12 @@ Restart Claude Code, and Claudia now has persistent memory.
 
 | Traditional AI | Claudia |
 |----------------|---------|
-| Forgets everything between sessions | **Persistent memory** — SQLite + vector search, never forgets |
+| Forgets everything between sessions | **Persistent memory** — SQLite + vector search, survives reboots |
 | Treats conversations as isolated | **Tracks relationships** — People files, not just tasks |
 | Waits for instructions | **Proactive** — Surfaces risks before they become problems |
 | One-size-fits-all | **Personalized** — Structure generated for your work style |
 | Cloud-based, data harvested | **Local** — Runs on your machine, your context stays yours |
+| Breaks after system updates | **Resilient** — Auto-starts on boot, retries on failure |
 
 ---
 
@@ -256,6 +254,44 @@ See what she surfaces. Then tell her about a person you work with.
 
 ---
 
+## Troubleshooting
+
+**Memory tools not appearing?**
+```bash
+# Check all services
+~/.claudia/diagnose.sh
+
+# Common fixes:
+# 1. Restart Claude Code in a NEW terminal (it reads .mcp.json at startup)
+# 2. Check daemon health: curl http://localhost:3848/health
+# 3. View logs: tail -f ~/.claudia/daemon-stderr.log
+```
+
+**Ollama not running after reboot?**
+```bash
+# Load the LaunchAgent
+launchctl load ~/Library/LaunchAgents/com.ollama.serve.plist
+
+# Or start manually
+ollama serve
+```
+
+**Vector search not working?**
+```bash
+# Check if sqlite-vec is installed
+~/.claudia/daemon/venv/bin/python -c "import sqlite_vec; print('ok')"
+
+# If not, install it
+~/.claudia/daemon/venv/bin/pip install sqlite-vec
+```
+
+**Pull the embedding model**
+```bash
+ollama pull all-minilm:l6-v2
+```
+
+---
+
 ## License
 
 Apache 2.0 — Use it, modify it, make it yours.

package/bin/index.js

@@ -56,37 +56,55 @@ async function main() {
   const args = process.argv.slice(2);
   const arg = args[0];
 
-  // Support "." for current directory
-  const isCurrentDir = arg === '.';
+  // Support "." or "upgrade" for current directory
+  const isCurrentDir = arg === '.' || arg === 'upgrade';
   const targetDir = isCurrentDir ? '.' : (arg || 'claudia');
   const targetPath = isCurrentDir ? process.cwd() : join(process.cwd(), targetDir);
   const displayDir = isCurrentDir ? 'current directory' : targetDir;
 
   // Check if directory already exists and has conflicting files
+  let isUpgrade = false;
+
   if (existsSync(targetPath)) {
     const contents = readdirSync(targetPath);
     const hasConflict = contents.some(f => f === 'CLAUDE.md' || f === '.claude');
+
     if (hasConflict) {
-      console.log(`\n${colors.yellow}⚠${colors.reset}  Claudia files already exist in ${displayDir}.`);
-      console.log(`   Remove CLAUDE.md and .claude/ first, or choose a different location.\n`);
-      process.exit(1);
+      // Check if this is an upgrade (existing memories to migrate)
+      const hasExistingMemories = existsSync(join(targetPath, 'context', 'me.md')) ||
+                                  existsSync(join(targetPath, 'context', 'learnings.md')) ||
+                                  existsSync(join(targetPath, 'context', 'patterns.md')) ||
+                                  existsSync(join(targetPath, 'people'));
+
+      if (hasExistingMemories) {
+        console.log(`\n${colors.cyan}✓${colors.reset} Found existing Claudia instance with memories.`);
+        isUpgrade = true;
+        // Don't exit - proceed to memory installation
+      } else {
+        // Fresh install conflict - exit as before
+        console.log(`\n${colors.yellow}⚠${colors.reset}  Claudia files already exist in ${displayDir}.`);
+        console.log(`   Remove CLAUDE.md and .claude/ first, or choose a different location.\n`);
+        process.exit(1);
+      }
     }
   }
 
-  // Create target directory if not current dir
-  if (!isCurrentDir) {
+  // Create target directory if not current dir (only for fresh installs)
+  if (!isCurrentDir && !isUpgrade) {
     mkdirSync(targetPath, { recursive: true });
   }
 
-  // Copy template files (v2 - minimal seed)
-  const templatePath = join(__dirname, '..', 'template-v2');
+  // Copy template files (v2 - minimal seed) - skip for upgrades
+  if (!isUpgrade) {
+    const templatePath = join(__dirname, '..', 'template-v2');
 
-  try {
-    cpSync(templatePath, targetPath, { recursive: true });
-    console.log(`${colors.green}✓${colors.reset} Installed in ${displayDir}`);
-  } catch (error) {
-    console.error(`\n${colors.yellow}⚠${colors.reset}  Error copying files: ${error.message}`);
-    process.exit(1);
+    try {
+      cpSync(templatePath, targetPath, { recursive: true });
+      console.log(`${colors.green}✓${colors.reset} Installed in ${displayDir}`);
+    } catch (error) {
+      console.error(`\n${colors.yellow}⚠${colors.reset}  Error copying files: ${error.message}`);
+      process.exit(1);
+    }
   }
 
   // Ask about enhanced memory system
@@ -113,10 +131,14 @@ async function main() {
 
     if (existsSync(memoryDaemonPath)) {
       try {
-        // Run the install script
+        // Run the install script, passing project path for upgrades
         const result = spawn('bash', [memoryDaemonPath], {
           stdio: 'inherit',
-          shell: true
+          shell: true,
+          env: {
+            ...process.env,
+            CLAUDIA_PROJECT_PATH: isUpgrade ? targetPath : ''
+          }
         });
 
         result.on('close', (code) => {

package/memory-daemon/scripts/install.sh

@@ -93,16 +93,34 @@ random_message() {
     echo "${MESSAGES[$RANDOM % ${#MESSAGES[@]}]}"
 }
 
-# Check Python
-echo -e "${BOLD}Step 1/7: Environment Check${NC}"
+# Check Python - prefer Homebrew Python on macOS (supports SQLite extensions)
+echo -e "${BOLD}Step 1/8: Environment Check${NC}"
 echo
-if command -v python3 &> /dev/null; then
-    PYTHON=$(command -v python3)
+PYTHON=""
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    # Homebrew Python supports SQLite extension loading (needed for vector search)
+    if [ -x "/opt/homebrew/bin/python3" ]; then
+        PYTHON="/opt/homebrew/bin/python3"
+        echo -e "  ${GREEN}✓${NC} Using Homebrew Python (vector search supported)"
+    elif [ -x "/usr/local/bin/python3" ]; then
+        PYTHON="/usr/local/bin/python3"
+        echo -e "  ${GREEN}✓${NC} Using Homebrew Python (vector search supported)"
+    fi
+fi
+
+if [ -z "$PYTHON" ]; then
+    if command -v python3 &> /dev/null; then
+        PYTHON=$(command -v python3)
+    fi
+fi
+
+if [ -n "$PYTHON" ]; then
     PYTHON_VERSION=$($PYTHON --version 2>&1 | awk '{print $2}')
-    echo -e "  ${GREEN}✓${NC} Python $PYTHON_VERSION"
+    echo -e "  ${GREEN}✓${NC} Python $PYTHON_VERSION ($PYTHON)"
 else
     echo -e "  ${RED}✗${NC} Python 3 not found"
     echo -e "    Please install Python 3.10 or later"
+    echo -e "    ${DIM}On macOS: brew install python${NC}"
     exit 1
 fi
 
@@ -181,7 +199,7 @@ echo -e "${DIM}━━━━━━━━━━━━━━━━━━━━━
 echo
 
 # Pull embedding model
-echo -e "${BOLD}Step 2/7: AI Models${NC}"
+echo -e "${BOLD}Step 2/8: AI Models${NC}"
 echo
 if [ "$OLLAMA_AVAILABLE" = true ]; then
     # Ensure Ollama is running before pulling model
@@ -230,7 +248,7 @@ echo -e "${DIM}━━━━━━━━━━━━━━━━━━━━━
 echo
 
 # Create directories
-echo -e "${BOLD}Step 3/7: Creating Home${NC}"
+echo -e "${BOLD}Step 3/8: Creating Home${NC}"
 echo
 mkdir -p "$DAEMON_DIR"
 mkdir -p "$MEMORY_DIR"
@@ -247,10 +265,11 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 SOURCE_DIR="$(dirname "$SCRIPT_DIR")"
 
 # Copy daemon files
-echo -e "${BOLD}Step 4/7: Installing Core${NC}"
+echo -e "${BOLD}Step 4/8: Installing Core${NC}"
 echo
 echo -e "  ${CYAN}◐${NC} Copying memory system files..."
 cp -r "$SOURCE_DIR/claudia_memory" "$DAEMON_DIR/"
+cp -r "$SOURCE_DIR/scripts" "$DAEMON_DIR/"
 cp "$SOURCE_DIR/pyproject.toml" "$DAEMON_DIR/"
 cp "$SOURCE_DIR/requirements.txt" "$DAEMON_DIR/"
 echo -e "  ${GREEN}✓${NC} Core files installed"
@@ -265,7 +284,7 @@ echo -e "${DIM}━━━━━━━━━━━━━━━━━━━━━
 echo
 
 # Create virtual environment
-echo -e "${BOLD}Step 5/7: Python Environment${NC}"
+echo -e "${BOLD}Step 5/8: Python Environment${NC}"
 echo
 echo -e "  ${CYAN}◐${NC} Creating isolated environment..."
 $PYTHON -m venv "$VENV_DIR"
@@ -290,7 +309,7 @@ echo -e "${DIM}━━━━━━━━━━━━━━━━━━━━━
 echo
 
 # Configure auto-start
-echo -e "${BOLD}Step 6/7: Auto-Start Setup${NC}"
+echo -e "${BOLD}Step 6/8: Auto-Start Setup${NC}"
 echo
 
 if [[ "$OSTYPE" == "darwin"* ]]; then
@@ -375,8 +394,40 @@ echo
 echo -e "${DIM}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
 echo
 
+# Memory Migration (for upgrades)
+echo -e "${BOLD}Step 7/8: Memory Migration${NC}"
+echo
+
+if [ -n "$CLAUDIA_PROJECT_PATH" ]; then
+    # Check if there are memories to migrate
+    if [ -d "$CLAUDIA_PROJECT_PATH/context" ] || [ -d "$CLAUDIA_PROJECT_PATH/people" ]; then
+        echo -e "  ${CYAN}◐${NC} Found existing memories to migrate..."
+
+        # Wait a moment for daemon to start
+        sleep 2
+
+        # Run migration in quiet mode
+        "$VENV_DIR/bin/python" "$DAEMON_DIR/scripts/migrate_markdown.py" --quiet "$CLAUDIA_PROJECT_PATH"
+
+        if [ $? -eq 0 ]; then
+            echo -e "  ${GREEN}✓${NC} Memories migrated to database"
+        else
+            echo -e "  ${YELLOW}!${NC} Migration had issues (memories still in markdown)"
+            echo -e "    ${DIM}You can retry manually: ~/.claudia/daemon/venv/bin/python -m claudia_memory.scripts.migrate_markdown $CLAUDIA_PROJECT_PATH${NC}"
+        fi
+    else
+        echo -e "  ${DIM}No existing memories found to migrate${NC}"
+    fi
+else
+    echo -e "  ${DIM}Fresh install - no migration needed${NC}"
+fi
+
+echo
+echo -e "${DIM}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo
+
 # Verify all services
-echo -e "${BOLD}Step 7/7: Verification${NC}"
+echo -e "${BOLD}Step 8/8: Verification${NC}"
 echo
 echo -e "  ${CYAN}◐${NC} Checking all services..."
 sleep 3

package/memory-daemon/scripts/migrate_markdown.py

@@ -346,13 +346,22 @@ def main():
         action="store_true",
         help="Enable debug logging",
     )
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Non-interactive mode (for automated migration)",
+    )
 
     args = parser.parse_args()
 
-    logging.basicConfig(
-        level=logging.DEBUG if args.debug else logging.INFO,
-        format="%(asctime)s - %(levelname)s - %(message)s",
-    )
+    if args.quiet:
+        # Suppress all logging in quiet mode
+        logging.basicConfig(level=logging.ERROR)
+    else:
+        logging.basicConfig(
+            level=logging.DEBUG if args.debug else logging.INFO,
+            format="%(asctime)s - %(levelname)s - %(message)s",
+        )
 
     # Initialize database
     db = get_db()
@@ -363,8 +372,24 @@ def main():
         if not args.path.exists():
             logger.error(f"Path not found: {args.path}")
             sys.exit(1)
+
+        if not args.quiet:
+            print(f"Migrating: {args.path}")
+
         stats = migrate_instance(args.path, args.dry_run)
-        print(f"\nMigrated: {stats}")
+
+        if args.quiet:
+            # Quiet mode - minimal output for automated migration
+            total = sum(stats.values())
+            if total > 0:
+                print(f"  - Migrated {stats['me']} items from context/me.md") if stats.get('me') else None
+                print(f"  - Migrated {stats['learnings']} items from context/learnings.md") if stats.get('learnings') else None
+                print(f"  - Migrated {stats['patterns']} items from context/patterns.md") if stats.get('patterns') else None
+                print(f"  - Migrated {stats['commitments']} items from context/commitments.md") if stats.get('commitments') else None
+                if stats.get('people'):
+                    print(f"  - Migrated {stats['people']} people with {stats.get('memories', 0)} facts")
+        else:
+            print(f"\nMigrated: {stats}")
 
     elif args.all:
         # Migrate all instances
@@ -373,11 +398,12 @@ def main():
             logger.info("No Claudia instances found")
             sys.exit(0)
 
-        print(f"Found {len(instances)} Claudia instance(s):\n")
-        for i, instance in enumerate(instances, 1):
-            print(f"  {i}. {instance}")
+        if not args.quiet:
+            print(f"Found {len(instances)} Claudia instance(s):\n")
+            for i, instance in enumerate(instances, 1):
+                print(f"  {i}. {instance}")
 
-        if not args.dry_run:
+        if not args.dry_run and not args.quiet:
             confirm = input("\nMigrate all? (y/n) ")
             if confirm.lower() != "y":
                 sys.exit(0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.2.5",
+  "version": "1.2.7",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",