MCP server logging and CLI enhancement for v1.0.0

Add comprehensive logging infrastructure for MCP server:
- New mcp/logger.go with thread-safe file logging to ~/.mimir/mcp.log
- Request/response logging with microsecond timestamps and timing info
- Debug logging in all 7 MCP tools (query, context, impact, detect_changes, rename, cypher)
- New 'mimir daemon logs [lines]' CLI command to view daemon logs
- Updated README documentation with logging features

This release marks v1.0.0 with complete MCP observability.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: thuongvh2

README.md

@@ -91,12 +91,23 @@ The result is a single static binary with zero external dependencies.
 
 ```bash
 # Index with full features (requires ollama or OpenAI for embeddings)
-mimir analyze /path/to/your/project
+mimir analyze /path/to/your-project
 
 # Index without embeddings (faster, graph + BM25 search only)
-mimir analyze --skip-embeddings /path/to/your/project
+mimir analyze --skip-embeddings /path/to/your-project
+
+# Skip auto-setup (daemon, hooks, skills) for manual control
+mimir analyze --skip-daemon --skip-hooks --skip-skills /path/to/your-project
 ```
 
+When you run `mimir analyze`, it automatically:
+1. **Indexes your code** into a knowledge graph
+2. **Starts the MCP daemon** for persistent background operation
+3. **Configures your editors** (Claude Code, VS Code, Cursor, Windsurf, Zed, OpenCode)
+4. **Installs Claude Code hooks** for auto-reindexing on file changes
+5. **Generates agent skills** — 4 static methodology skills + dynamic module skills per cluster
+6. **Creates context files** — AGENTS.md and CLAUDE.md with live index statistics
+
 ### 2. Explore via Web UI
 
 ```bash
@@ -115,8 +126,20 @@ The web UI provides:
 ### 3. Use with AI Agents (MCP)
 
 ```bash
-# Start the MCP stdio server
-mimir mcp
+# Start the MCP stdio server (or let analyze start it for you)
+mimir daemon start
+
+# Check daemon status
+mimir daemon status
+
+# View MCP logs (last 30 lines)
+mimir daemon logs
+
+# View last 100 lines
+mimir daemon logs 100
+
+# Stop the daemon
+mimir daemon stop
 ```
 
 Or configure in your editor's MCP settings:
@@ -144,19 +167,35 @@ mimir setup
 
 | Command | Description |
 |---|---|
-| `mimir analyze <path>` | Index a repository into the knowledge graph |
+| `mimir analyze <path>` | Index a repository into the knowledge graph with auto-setup |
 | `mimir serve` | Start the HTTP server + web UI (default: port 7842) |
 | `mimir mcp` | Start the MCP stdio server for AI agent integration |
+| `mimir daemon start` | Start the MCP daemon in the background |
+| `mimir daemon stop` | Stop the MCP daemon |
+| `mimir daemon status` | Show daemon status and uptime |
+| `mimir daemon restart` | Restart the MCP daemon |
+| `mimir daemon logs [lines]` | View MCP daemon logs (default: 30 lines) |
 | `mimir list` | List all indexed repositories |
 | `mimir status [name]` | Show index status for a repository |
 | `mimir clean <name>` | Remove the index for a repository |
-| `mimir setup` | Configure MCP settings in supported editors |
+| `mimir setup` | Configure MCP settings in all supported editors |
 | `mimir wiki [name]` | Generate a wiki from the knowledge graph |
 
-### Flags
+### Analyze Flags
 
 ```bash
 mimir analyze --skip-embeddings <path>   # Skip embedding generation
+mimir analyze --skip-daemon <path>       # Don't start MCP daemon
+mimir analyze --skip-hooks <path>        # Don't install Claude Code hooks
+mimir analyze --skip-skills <path>       # Don't install agent skills
+mimir analyze --force <path>             # Force full re-index even if up to date
+mimir analyze --incremental <path>       # Force incremental mode
+mimir analyze --hint <file> <path>       # Hint for faster patch planning
+```
+
+### Other Flags
+
+```bash
 mimir serve --port 8080                  # Custom port (default: 7842)
 ```
 
@@ -192,7 +231,82 @@ When connected via MCP, AI agents get access to 7 tools:
 | `detect_changes` | Detect uncommitted/recent git changes and their impact |
 | `rename` | Plan a coordinated multi-file rename |
 | `cypher` | Execute raw graph queries |
-| `reindex` | Trigger incremental re-indexing |
+| `list_repos` | List all indexed repositories |
+
+---
+
+## Auto-Analyze Features
+
+When you run `mimir analyze`, Mimir sets up a complete AI-powered development environment automatically:
+
+### 1. MCP Daemon
+
+The daemon runs in the background, keeping the MCP server always available:
+
+```bash
+mimir daemon start    # Start background daemon
+mimir daemon status   # Check status and uptime
+mimir daemon logs     # View last 30 log lines
+mimir daemon logs 100 # View last 100 log lines
+mimir daemon stop     # Stop daemon
+```
+
+**Log file location**: `~/.mimir/mimir-mcp.log`
+
+The daemon logs all MCP requests, tool calls, errors, and timing information for debugging.
+
+### 2. Editor Auto-Configuration
+
+Mimir detects and configures MCP settings for:
+- Claude Code
+- VS Code (Copilot)
+- Cursor
+- Windsurf
+- Zed
+- OpenCode
+
+### 3. Claude Code Hooks
+
+Two bash hooks enhance your Claude Code experience:
+
+**Pre-Search Hook** (`mimir-pre-search.sh`):
+- Intercepts `grep`, `rg`, `find`, and `Glob` tool calls
+- Automatically queries the Mimir graph for context
+- Augments search results with graph intelligence
+
+**Post-Write Hook** (`mimir-post-write.sh`):
+- Triggers after file writes or git commits
+- Runs incremental re-indexing automatically
+- Fire-and-forget (never blocks Claude)
+
+Hooks are installed to `.claude/hooks/` and configured in `.claude/settings.json`.
+
+### 4. Agent Skills
+
+Mimir installs specialized skills for AI agents:
+
+**Static Skills** (always installed):
+- `exploring.md` — Navigate code using the knowledge graph
+- `debugging.md` — Trace bugs through call chains
+- `impact-analysis.md` — Analyze blast radius before edits
+- `refactoring.md` — Plan safe multi-file refactors
+
+**Dynamic Module Skills** (generated per project):
+- One skill per detected code cluster/module
+- Includes key files, entry points, and dependencies
+- Skips low-cohesion clusters (< 0.3 score)
+
+Skills are installed to `.claude/skills/mimir/`.
+
+### 5. Context Files
+
+**AGENTS.md** and **CLAUDE.md** are generated with:
+- Live index statistics (symbols, edges, clusters, processes)
+- Functional cluster list with cohesion scores
+- Execution flow traces
+- MCP tool usage guidelines
+
+Read these files before starting work to understand the codebase structure.
 
 ---
 
@@ -265,7 +379,3 @@ mimir/
 ```
 
 ---
-
-## License
-
-MIT

internal/daemon/daemon.go

@@ -0,0 +1,178 @@
+package daemon
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+)
+
+const (
+	pidFile  = "mimir-mcp.pid"
+	logFile  = "mimir-mcp.log"
+	dataDir  = ".mimir"
+)
+
+// PIDPath returns the path to the PID file in ~/.mimir/
+func PIDPath() string {
+	home, _ := os.UserHomeDir()
+	return filepath.Join(home, dataDir, pidFile)
+}
+
+// LogPath returns the path to the log file in ~/.mimir/
+func LogPath() string {
+	home, _ := os.UserHomeDir()
+	return filepath.Join(home, dataDir, logFile)
+}
+
+// DataDir returns the path to the ~/.mimir directory
+func DataDir() string {
+	home, _ := os.UserHomeDir()
+	return filepath.Join(home, dataDir)
+}
+
+// ensureDir creates the ~/.mimir directory if it doesn't exist
+func ensureDir() error {
+	return os.MkdirAll(DataDir(), 0755)
+}
+
+// Start launches mimir mcp as a detached background process.
+// Returns early if already running.
+func Start(mimirBin string) error {
+	if IsRunning() {
+		return nil // already up
+	}
+
+	if err := ensureDir(); err != nil {
+		return fmt.Errorf("create data dir: %w", err)
+	}
+
+	logF, err := os.OpenFile(LogPath(), os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
+	if err != nil {
+		return fmt.Errorf("open log: %w", err)
+	}
+
+	cmd := exec.Command(mimirBin, "mcp")
+	cmd.Stdout = logF
+	cmd.Stderr = logF
+	// Detach from parent process group so it survives terminal close
+	cmd.SysProcAttr = sysProcDetach()
+
+	if err := cmd.Start(); err != nil {
+		logF.Close()
+		return fmt.Errorf("start daemon: %w", err)
+	}
+
+	// Write PID
+	pidStr := strconv.Itoa(cmd.Process.Pid)
+	if err := os.WriteFile(PIDPath(), []byte(pidStr), 0644); err != nil {
+		logF.Close()
+		return fmt.Errorf("write pid: %w", err)
+	}
+
+	return nil
+}
+
+// Stop sends SIGINT to the daemon process.
+func Stop() error {
+	pid, err := readPID()
+	if err != nil {
+		return nil // not running
+	}
+
+	proc, err := os.FindProcess(pid)
+	if err != nil {
+		os.Remove(PIDPath())
+		return nil
+	}
+
+	os.Remove(PIDPath())
+	return proc.Signal(os.Interrupt)
+}
+
+// Restart stops and then starts the daemon.
+func Restart(mimirBin string) error {
+	Stop()
+	// Give it a moment to fully stop
+	time.Sleep(100 * time.Millisecond)
+	return Start(mimirBin)
+}
+
+// IsRunning checks whether the daemon PID is alive.
+func IsRunning() bool {
+	pid, err := readPID()
+	if err != nil {
+		return false
+	}
+
+	proc, err := os.FindProcess(pid)
+	if err != nil {
+		return false
+	}
+
+	// Signal 0 = check existence only
+	return proc.Signal(syscall.Signal(0)) == nil
+}
+
+// WatchAndRestart keeps the daemon alive — call from a supervisor goroutine.
+func WatchAndRestart(mimirBin string, interval time.Duration) {
+	for {
+		time.Sleep(interval)
+		if !IsRunning() {
+			if err := Start(mimirBin); err != nil {
+				// Log error but keep trying
+				fmt.Fprintf(os.Stderr, "daemon restart failed: %v\n", err)
+			}
+		}
+	}
+}
+
+// ReadPID returns the current daemon PID.
+func ReadPID() (int, error) {
+	return readPID()
+}
+
+// GetUptime returns how long the daemon has been running.
+func GetUptime() (time.Duration, error) {
+	if _, err := readPID(); err != nil {
+		return 0, fmt.Errorf("not running")
+	}
+
+	// Use PID file modification time as proxy for process start time
+	if stat, err := os.Stat(PIDPath()); err == nil {
+		return time.Since(stat.ModTime()), nil
+	}
+
+	return 0, fmt.Errorf("could not determine uptime")
+}
+
+// LogTail returns the last N lines of the daemon log.
+func LogTail(lines int) ([]string, error) {
+	logPath := LogPath()
+	data, err := os.ReadFile(logPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return []string{}, nil
+		}
+		return nil, err
+	}
+
+	allLines := strings.Split(strings.TrimSpace(string(data)), "\n")
+	if len(allLines) <= lines {
+		return allLines, nil
+	}
+
+	return allLines[len(allLines)-lines:], nil
+}
+
+func readPID() (int, error) {
+	b, err := os.ReadFile(PIDPath())
+	if err != nil {
+		return 0, err
+	}
+	return strconv.Atoi(strings.TrimSpace(string(b)))
+}