智能会话分叉检测

git clone https://github.com/recursive-vibe/smart-fork.git
cd Smart-Fork

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

pip install -e .

pip install smart-fork

python -c "import smart_fork; print(smart_fork.__version__)"

{
  "mcpServers": {
    "smart-fork": {
      "command": "/path/to/smart-fork/venv/bin/python",
      "args": ["-m", "smart_fork.server"],
      "cwd": "/path/to/smart-fork/src",
      "env": {
        "PYTHONPATH": "/path/to/smart-fork/src"
      }
    }
  }
}

You: Use the fork-detect tool to search for "WebSocket real-time updates"

Found 5 relevant sessions:

⭐ [1] Session abc123 (92% match) - Recommended
   Date: 2026-01-15
   Project: my-dashboard
   Preview: "Implemented real-time updates using WebSocket connection with
            automatic reconnection logic..."

[2] Session def456 (81% match)
   Date: 2026-01-10
   Project: my-dashboard
   Preview: "Added dashboard component with live data updates and polling
            fallback..."

[3] Session ghi789 (67% match)
   Date: 2025-12-20
   Project: admin-portal
   Preview: "Created WebSocket handler for server-sent events with proper
            error handling..."

[4] None - start fresh

[5] Type something else

claude --resume abc123 --fork-session

/fork abc123 /path/to/project

"embedding": {
  "model_name": "sentence-transformers/all-MiniLM-L6-v2",
  "dimension": 384,
  "batch_size": 32,
  "max_batch_size": 128,
  "min_batch_size": 8
}

"search": {
  "k_chunks": 200,
  "top_n_sessions": 5,
  "preview_length": 200,
  "similarity_threshold": 0.3,
  "recency_weight": 0.25
}

"chunking": {
  "target_tokens": 750,
  "overlap_tokens": 150,
  "max_tokens": 1000
}

"indexing": {
  "debounce_delay": 5.0,
  "checkpoint_interval": 15,
  "enabled": true
}

"setup": {
  "timeout_per_session": 30.0
}

from smart_fork.initial_setup import InitialSetup

# Increase timeout for large files
setup = InitialSetup(timeout_per_session=60.0)
result = setup.run_setup()

# Or retry previously timed-out sessions
if result.get('timeouts'):
    print(f"{len(result['timeouts'])} sessions timed out")
    result = setup.run_setup(resume=True, retry_timeouts=True)

from smart_fork.initial_setup import InitialSetup

# Use 4 worker threads for parallel processing
setup = InitialSetup(workers=4)
result = setup.run_setup()

print(f"Processed {result['files_processed']} files using {result['workers_used']} workers")
print(f"Elapsed time: {result['elapsed_time']:.1f}s")

# Typical speedup with multiple workers:
# - 2 workers: 1.5-1.8x faster
# - 4 workers: 2-3x faster
# - 8 workers: 3-4x faster (diminishing returns due to I/O)

# Run initial setup in batch mode (recommended)
python -m smart_fork.initial_setup --batch-mode

# Custom batch size (default: 5 sessions per batch)
python -m smart_fork.initial_setup --batch-mode --batch-size 10

# Force CPU mode to reduce memory usage
python -m smart_fork.initial_setup --batch-mode --use-cpu

# All batch mode options
python -m smart_fork.initial_setup --batch-mode --batch-size 5 --use-cpu --timeout 60

"server": {
  "host": "127.0.0.1",
  "port": 8741
}

"memory": {
  "max_memory_mb": 2000,
  "gc_between_batches": true
}

"storage_dir": "~/.smart-fork"

{
  "embedding": {
    "model_name": "sentence-transformers/all-MiniLM-L6-v2",
    "dimension": 384,
    "batch_size": 32,
    "max_batch_size": 128,
    "min_batch_size": 8
  },
  "search": {
    "k_chunks": 200,
    "top_n_sessions": 5,
    "preview_length": 200,
    "similarity_threshold": 0.3,
    "recency_weight": 0.25
  },
  "chunking": {
    "target_tokens": 750,
    "overlap_tokens": 150,
    "max_tokens": 1000
  },
  "indexing": {
    "debounce_delay": 5.0,
    "checkpoint_interval": 15,
    "enabled": true
  },
  "server": {
    "host": "127.0.0.1",
    "port": 8741
  },
  "memory": {
    "max_memory_mb": 2000,
    "gc_between_batches": true
  },
  "storage_dir": "~/.smart-fork"
}

Final Score = (best_similarity × 0.40)
            + (avg_similarity × 0.20)
            + (chunk_ratio × 0.05)
            + (recency × 0.25)
            + (chain_quality × 0.10)

{
  "embedding": {
    "batch_size": 16,
    "max_batch_size": 32
  },
  "memory": {
    "max_memory_mb": 1000,
    "gc_between_batches": true
  }
}

{
  "embedding": {
    "batch_size": 64,
    "max_batch_size": 256
  },
  "search": {
    "k_chunks": 300
  },
  "memory": {
    "max_memory_mb": 4000
  }
}

{
  "search": {
    "k_chunks": 100,
    "similarity_threshold": 0.5
  }
}

# Stop Claude Code first
rm -rf ~/.smart-fork/

You: I need to implement real-time notifications with WebSocket.
     Can you help me find my previous work on this?

Claude: [Invokes fork-detect tool automatically]

Fork Detection Results:
⭐ [1] Session abc123 (94% match) - Recommended
   Date: 2026-01-10
   Project: my-dashboard
   Preview: "Set up WebSocket connection with automatic reconnection,
            heartbeat ping/pong, and exponential backoff..."

[2] Session def456 (81% match)
   ...

To fork from the recommended session, run:
Terminal command: claude --resume abc123 --fork-session

You: (paste command in new terminal)
Claude: (continues with full context from the dashboard implementation)

You: I'm seeing a memory leak in React components again.
     Can you find my previous debugging session on this?

Claude: [Invokes fork-detect tool]

Fork Detection Results:
⭐ [1] Session def456 (89% match) - Recommended
   Date: 2025-12-28
   Project: web-app
   Preview: "Identified memory leak caused by missing cleanup in useEffect.
            Added return function to cancel subscriptions and clear intervals..."

To fork from this session, run:
claude --resume def456 --fork-session

You: (pastes command to continue)

You: I need to continue refactoring the authentication module from my
     previous session. Can you find where I left off?

Claude: [Invokes fork-detect tool]

Fork Detection Results:
⭐ [1] Session ghi789 (98% match) - Recommended
   Date: Today, 2 hours ago
   Project: api-server
   Preview: "Refactoring auth module: completed user service, working on
            token validation. Next: implement refresh token rotation..."

To continue from where you left off, run:
claude --resume ghi789 --fork-session

You: (continues seamlessly)

# First approach
You: Find my work on implementing settings page with form validation

Claude: [Shows results, you fork to session with React + Formik]

# Later, try another approach
You: Find that same settings page session again, I want to try
     a different approach

Claude: [Shows same results]

You: Let's fork from that session but use Vue 3 with Vuelidate instead

You: Can you help me understand this project's structure and coding patterns?
     Find any sessions where the architecture was discussed.

Claude: [Invokes fork-detect tool]

Fork Detection Results:
⭐ [1] Session jkl012 (85% match) - Recommended
   Date: 2025-11-15
   Project: api-server
   Preview: "Explained project architecture: 3-tier design with controllers,
            services, and repositories. Error handling uses custom exception
            classes..."

To review this architectural discussion, run:
claude --resume jkl012 --fork-session

from smart_fork.background_indexer import BackgroundIndexer
from smart_fork.embedding_service import EmbeddingService
from smart_fork.vector_db_service import VectorDBService
from smart_fork.session_registry import SessionRegistry

# Initialize services
embedding_service = EmbeddingService()
vector_db = VectorDBService()
registry = SessionRegistry()

# Create indexer
indexer = BackgroundIndexer(
    embedding_service=embedding_service,
    vector_db=vector_db,
    registry=registry
)

# Index a specific file
indexer.index_file("/path/to/session.jsonl")

from smart_fork.search_service import SearchService

# Initialize search service
search_service = SearchService(
    embedding_service=embedding_service,
    vector_db=vector_db,
    scoring_service=scoring_service,
    registry=registry
)

# Search for sessions
results = search_service.search(
    query="implement user authentication",
    k_chunks=200,
    top_n_sessions=5
)

for result in results:
    print(f"{result.session_id}: {result.score:.2%} - {result.preview[:100]}")

{
  "embedding": {
    "model_name": "sentence-transformers/all-MiniLM-L6-v2",
    "dimension": 384
  }
}

from smart_fork.vector_db_service import VectorDBService

vector_db = VectorDBService()
stats = vector_db.get_stats()

print(f"Total chunks: {stats['total_chunks']}")
print(f"Total sessions: {stats['total_sessions']}")