完全接管session 管理
kimi.session.md

# Kimi CLI Session 命令 - 会话数据同步

你正在执行 **Kimi CLI Session 命令**。请按照以下逻辑处理用户的会话同步请求。

---

例子 用户输入：code:/kimi.session $ARGUMENTS
当$ARGUMENTS 为空，则直接 进行session同步操作。
## 命令解析

**用户输入**: `$ARGUMENTS`

**命令**: session
**子命令**: 从 `$ARGUMENTS` 中提取第一个单词
**参数**: 剩余部分作为参数

---

## 执行步骤

### **Step 1: 解析子命令**
```python
import json
import os
import shutil
from pathlib import Path
from datetime import datetime

# 解析用户输入
args = "$ARGUMENTS".strip().split() if "$ARGUMENTS" else ["sync"]
subcommand = args[0] if args else "sync"
param = " ".join(args[1:]) if len(args) > 1 else None

print(f"🔍 执行 Session 命令: {subcommand}")
if param:
    print(f"📄 参数: {param}")

Step 2: 定义目录路径

# Kimi 全局会话存储目录
KIMI_SESSIONS_DIR = Path(os.path.expandvars("%USERPROFILE%/.kimi/sessions"))

# 当前项目的会话目录
CURRENT_SESSION_DIR = Path(".kimi/session")
CURRENT_SESSION_INFO = Path(".kimi/curr_session_llm/curr_session.json")

print(f"📁 Kimi 全局会话目录: {KIMI_SESSIONS_DIR}")
print(f"📁 当前项目会话目录: {CURRENT_SESSION_DIR}")
print(f"📄 当前会话信息文件: {CURRENT_SESSION_INFO}")

Step 3: 检查目录存在性

if not KIMI_SESSIONS_DIR.exists():
    print(f"❌ 未找到 Kimi 全局会话目录: {KIMI_SESSIONS_DIR}")
    print("请确认 Kimi CLI 已正确安装并使用过")
    exit(1)

# 确保当前项目目录结构存在
CURRENT_SESSION_DIR.mkdir(parents=True, exist_ok=True)
CURRENT_SESSION_INFO.parent.mkdir(parents=True, exist_ok=True)

print(f"✅ 目录检查完成")

Step 4: 获取当前工作目录信息

def get_working_dir_info():
    """获取当前工作目录的关键信息"""
    current_dir = Path.cwd()
    
    # 获取项目根目录标识
    project_markers = ['.git', 'package.json', 'requirements.txt', 'pyproject.toml', '.env']
    project_root = current_dir
    
    # 向上查找项目根目录
    for marker in project_markers:
        if (current_dir / marker).exists():
            project_root = current_dir
            break
        else:
            # 向上遍历父目录
            for parent in current_dir.parents:
                if (parent / marker).exists():
                    project_root = parent
                    break
    
    return {
        'current_dir': str(current_dir),
        'project_root': str(project_root),
        'project_name': project_root.name,
        'sync_time': datetime.now().isoformat()
    }

def find_matching_sessions(working_dir_info):
    """在全局会话目录中查找匹配的会话"""
    matching_sessions = []
    
    if not KIMI_SESSIONS_DIR.exists():
        return matching_sessions
    
    # 遍历所有会话目录
    for session_dir in KIMI_SESSIONS_DIR.iterdir():
        if not session_dir.is_dir():
            continue
            
        # 检查会话是否属于当前项目
        for jsonl_file in session_dir.glob("*.jsonl"):
            try:
                with open(jsonl_file, 'r', encoding='utf-8') as f:
                    content = f.read()
                    
                    # 检查是否包含当前工作目录路径
                    if working_dir_info['current_dir'] in content or working_dir_info['project_root'] in content:
                        matching_sessions.append({
                            'session_id': session_dir.name,
                            'jsonl_file': jsonl_file.name,
                            'file_path': str(jsonl_file),
                            'last_modified': jsonl_file.stat().st_mtime,
                            'file_size': jsonl_file.stat().st_size
                        })
                        break
            except Exception as e:
                continue
    
    return matching_sessions

# 获取工作目录信息
working_info = get_working_dir_info()
print(f"📂 当前工作目录: {working_info['current_dir']}")
print(f"🏠 项目根目录: {working_info['project_root']}")

# 查找匹配的会话
matching_sessions = find_matching_sessions(working_info)
print(f"🔍 找到 {len(matching_sessions)} 个匹配的会话")

Step 5: 实现子命令功能

情况 A: sync - 同步会话数据（默认）

if subcommand == "sync":
    print(f"\n{'='*60}")
    print("🔄 开始同步会话数据...")
    print(f"{'='*60}")
    
    if not matching_sessions:
        print("⚠️  未找到与当前项目相关的会话")
        print("\n💡 提示:")
        print("- 确保已经在当前目录使用过 Kimi CLI")
        print("- 检查全局会话目录是否存在数据")
        print("- 使用 'list' 子命令查看所有会话")
        exit(0)
    
    # 按修改时间排序，最新的在前
    matching_sessions.sort(key=lambda x: x['last_modified'], reverse=True)
    
    # 同步最新的会话
    sync_count = 0
    for session in matching_sessions[:3]:  # 同步最新的3个会话
        try:
            src_file = Path(session['file_path'])
            dst_file = CURRENT_SESSION_DIR / f"{session['session_id']}_{session['jsonl_file']}"
            
            # 复制文件
            shutil.copy2(src_file, dst_file)
            sync_count += 1
            
            print(f"✅ 已同步: {session['session_id']}")
            print(f"   文件: {session['jsonl_file']}")
            print(f"   大小: {session['file_size']} 字节")
            print(f"   时间: {datetime.fromtimestamp(session['last_modified']).strftime('%Y-%m-%d %H:%M:%S')}")
            
        except Exception as e:
            print(f"❌ 同步失败: {session['session_id']} - {str(e)}")
    
    # 记录当前会话信息
    session_info = {
        'sync_time': working_info['sync_time'],
        'working_dir': working_info['current_dir'],
        'project_root': working_info['project_root'],
        'project_name': working_info['project_name'],
        'synced_sessions': [
            {
                'session_id': s['session_id'],
                'file': s['jsonl_file'],
                'last_modified': s['last_modified']
            } for s in matching_sessions[:3]
        ],
        'total_synced': sync_count
    }
    
    # 保存会话信息到文件
    with open(CURRENT_SESSION_INFO, 'w', encoding='utf-8') as f:
        json.dump(session_info, f, ensure_ascii=False, indent=2)
    
    print(f"\n{'='*60}")
    print(f"✅ 同步完成！共同步 {sync_count} 个会话")
    print(f"📄 会话信息已保存到: {CURRENT_SESSION_INFO}")
    print(f"📁 同步文件保存在: {CURRENT_SESSION_DIR}")
    print(f"{'='*60}")

情况 B: list - 列出可同步的会话

elif subcommand == "list":
    print(f"\n{'='*60}")
    print("📋 可同步的会话列表")
    print(f"{'='*60}")
    
    if not matching_sessions:
        print("⚠️  未找到与当前项目相关的会话")
        print("\n💡 提示:")
        print("- 确保已经在当前目录使用过 Kimi CLI")
        print("- 检查全局会话目录是否存在数据")
        exit(0)
    
    # 按修改时间排序
    matching_sessions.sort(key=lambda x: x['last_modified'], reverse=True)
    
    for i, session in enumerate(matching_sessions, 1):
        print(f"\n{i}. **会话ID**: `{session['session_id']}`")
        print(f"   **对话文件**: {session['jsonl_file']}")
        print(f"   **文件大小**: {session['file_size']} 字节")
        print(f"   **最后修改**: {datetime.fromtimestamp(session['last_modified']).strftime('%Y-%m-%d %H:%M:%S')}")
        
        # 检查是否已同步
        synced_file = CURRENT_SESSION_DIR / f"{session['session_id']}_{session['jsonl_file']}"
        if synced_file.exists():
            print(f"   **同步状态**: ✅ 已同步")
        else:
            print(f"   **同步状态**: ⏳ 未同步")
    
    print(f"\n{'='*60}")
    print(f"💡 **使用说明**:")
    print(f"- 使用 'sync' 子命令同步所有会话")
    print(f"- 使用 'show <session_id>' 查看会话详情")
    print(f"- 使用 'clear' 清理本地同步的会话")
    print(f"{'='*60}")

情况 C: show <session_id> - 显示会话详情

elif subcommand == "show":
    if not param:
        print("❌ 请提供会话ID")
        print("用法: /kimi.session show <session_id>")
        exit(1)
    
    session_id = param.strip()
    
    # 在匹配的会话中查找
    target_session = None
    for session in matching_sessions:
        if session['session_id'] == session_id:
            target_session = session
            break
    
    if not target_session:
        print(f"❌ 未找到会话: {session_id}")
        print("💡 使用 'list' 子命令查看所有可用会话")
        exit(1)
    
    print(f"\n{'='*60}")
    print(f"📋 会话详情: {session_id}")
    print(f"{'='*60}")
    
    # 读取对话内容进行分析
    jsonl_file = Path(target_session['file_path'])
    try:
        with open(jsonl_file, 'r', encoding='utf-8') as f:
            lines = f.readlines()
            
        # 分析对话内容
        user_messages = 0
        assistant_messages = 0
        first_message_time = None
        last_message_time = None
        
        for line in lines:
            try:
                data = json.loads(line)
                role = data.get('role', '')
                
                if role == 'user':
                    user_messages += 1
                elif role == 'assistant':
                    assistant_messages += 1
                
                # 获取时间信息
                create_time = data.get('create_time')
                if create_time:
                    if not first_message_time:
                        first_message_time = create_time
                    last_message_time = create_time
            except:
                continue
        
        print(f"**对话文件**: {target_session['jsonl_file']}")
        print(f"**文件大小**: {target_session['file_size']} 字节")
        print(f"**最后修改**: {datetime.fromtimestamp(target_session['last_modified']).strftime('%Y-%m-%d %H:%M:%S')}")
        print(f"**用户消息**: {user_messages} 条")
        print(f"**助手消息**: {assistant_messages} 条")
        print(f"**总消息数**: {user_messages + assistant_messages} 条")
        
        if first_message_time and last_message_time:
            print(f"**对话时间**: {first_message_time} - {last_message_time}")
        
        # 显示最近的几条消息摘要
        print(f"\n{'='*60}")
        print("最近对话摘要:")
        print(f"{'='*60}")
        
        recent_lines = lines[-10:] if len(lines) > 10 else lines
        for line in recent_lines:
            try:
                data = json.loads(line)
                role = data.get('role', '')
                content = data.get('content', '')
                
                if isinstance(content, list) and content:
                    text = content[0].get('text', '') if isinstance(content[0], dict) else str(content[0])
                else:
                    text = str(content)
                
                # 清理文本
                text = text.strip()
                if text:
                    # 截断过长的文本
                    if len(text) > 150:
                        text = text[:150] + "..."
                    
                    role_emoji = "👤" if role == 'user' else "🤖"
                    print(f"{role_emoji} {text}")
                    
            except:
                continue
        
        print(f"\n{'='*60}")
        print(f"💡 **操作选项**:")
        print(f"- 使用 'sync' 同步此会话到本地")
        print(f"- 使用 'resume {session_id}' 恢复此会话")
        print(f"{'='*60}")
        
    except Exception as e:
        print(f"❌ 读取会话文件失败: {str(e)}")

情况 D: clear - 清理本地同步的会话

elif subcommand == "clear":
    print(f"\n{'='*60}")
    print("🗑️  清理本地同步的会话...")
    print(f"{'='*60}")
    
    # 检查是否有同步的文件
    synced_files = list(CURRENT_SESSION_DIR.glob("*.jsonl"))
    
    if not synced_files:
        print("⚠️  没有找到本地同步的会话文件")
        exit(0)
    
    print(f"📊 找到 {len(synced_files)} 个同步的会话文件")
    
    # 显示要删除的文件
    for i, file in enumerate(synced_files, 1):
        print(f"{i}. {file.name} ({file.stat().st_size} 字节)")
    
    # 删除文件
    deleted_count = 0
    for file in synced_files:
        try:
            file.unlink()
            deleted_count += 1
        except Exception as e:
            print(f"❌ 删除失败: {file.name} - {str(e)}")
    
    # 清理会话信息文件
    if CURRENT_SESSION_INFO.exists():
        try:
            CURRENT_SESSION_INFO.unlink()
        except:
            pass
    
    print(f"\n✅ 清理完成！已删除 {deleted_count} 个文件")
    print(f"📁 本地会话目录已清空: {CURRENT_SESSION_DIR}")

情况 E: status - 显示同步状态

elif subcommand == "status":
    print(f"\n{'='*60}")
    print("📊 会话同步状态")
    print(f"{'='*60}")
    
    # 检查当前会话信息
    if CURRENT_SESSION_INFO.exists():
        try:
            with open(CURRENT_SESSION_INFO, 'r', encoding='utf-8') as f:
                session_info = json.load(f)
            
            print(f"**最后同步时间**: {session_info.get('sync_time', '未知')}")
            print(f"**工作目录**: {session_info.get('working_dir', '未知')}")
            print(f"**项目名称**: {session_info.get('project_name', '未知')}")
            print(f"**同步的会话数**: {session_info.get('total_synced', 0)} 个")
            
            synced_sessions = session_info.get('synced_sessions', [])
            if synced_sessions:
                print(f"\n**已同步的会话**:")
                for i, session in enumerate(synced_sessions, 1):
                    print(f"{i}. {session['session_id']} - {session['file']}")
            
        except Exception as e:
            print(f"❌ 读取会话信息失败: {str(e)}")
    else:
        print("⚠️  尚未进行过会话同步")
    
    # 检查本地同步的文件
    synced_files = list(CURRENT_SESSION_DIR.glob("*.jsonl"))
    print(f"\n**本地同步文件**: {len(synced_files)} 个")
    
    if synced_files:
        total_size = sum(f.stat().st_size for f in synced_files)
        print(f"**总大小**: {total_size} 字节")
        
        print(f"\n**文件列表**:")
        for file in synced_files:
            print(f"- {file.name} ({file.stat().st_size} 字节)")
    
    print(f"\n{'='*60}")

默认情况: 显示帮助

else:
    print(f"❌ 未知子命令: {subcommand}")
    print(f"\n{'='*60}")
    print("📖 可用子命令:")
    print("- `sync` - 同步会话数据（默认）")
    print("- `list` - 列出可同步的会话")
    print("- `show <session_id>` - 显示会话详情")
    print("- `clear` - 清理本地同步的会话")
    print("- `status` - 显示同步状态")
    print(f"{'='*60}")
    print("💡 示例:")
    print("  /kimi.session sync")
    print("  /kimi.session list")
    print("  /kimi.session show dcc1f6970f1ebea26417a3b8398655ce")
    print("  /kimi.session clear")
    print("  /kimi.session status")
    print(f"{'='*60}")

执行完成 ✅

这个命令提供了完整的会话数据同步功能，可以：

自动识别与当前项目相关的会话
同步会话数据到本地项目目录
管理和查看同步状态
清理本地同步的数据
为会话恢复功能提供数据基础


<!--This is a translation content dividing line, the content below is generated by machine, please do not modify the content below-->
---
Completely take over session management
kimi.session.md

Kimi CLI Session Command - Session Data Synchronization

You are executing the Kimi CLI Session command. Please follow the following logic to handle the user's session synchronization request.

Example User input: code:/kimi.session $ARGUMENTS
When $ARGUMENTS is empty, session synchronization operation is performed directly.

Command parsing

User input: $ARGUMENTS

Command: session
Subcommand: Extract the first word from $ARGUMENTS
Parameters: The remaining parts are used as parameters

Execution steps

Step 1: Parse subcommands

import json
import os
import shutil
from pathlib import Path
from datetime import datetime

# Parse user input
args = "$ARGUMENTS".strip().split() if "$ARGUMENTS" else ["sync"]
subcommand = args[0] if args else "sync"
param = " ".join(args[1:]) if len(args) > 1 else None

print(f"🔍 Execute Session command: {subcommand}")
if param:
    print(f"📄 Parameter: {param}")

Step 2: Define directory path

# Kimi global session storage directory
KIMI_SESSIONS_DIR = Path(os.path.expandvars("%USERPROFILE%/.kimi/sessions"))

# Session directory of the current project
CURRENT_SESSION_DIR = Path(".kimi/session")
CURRENT_SESSION_INFO = Path(".kimi/curr_session_llm/curr_session.json")

print(f"📁 Kimi global session directory: {KIMI_SESSIONS_DIR}")
print(f"📁 Current project session directory: {CURRENT_SESSION_DIR}")
print(f"📄 Current session information file: {CURRENT_SESSION_INFO}")

Step 3: Check directory existence

if not KIMI_SESSIONS_DIR.exists():
    print(f"❌ Kimi global session directory not found: {KIMI_SESSIONS_DIR}")
    print("Please confirm that Kimi CLI has been installed and used correctly")
    exit(1)

# Make sure the current project directory structure exists
CURRENT_SESSION_DIR.mkdir(parents=True, exist_ok=True)
CURRENT_SESSION_INFO.parent.mkdir(parents=True, exist_ok=True)

print(f"✅ Directory check completed")

Step 4: Get current working directory information

def get_working_dir_info():
    """Get key information of the current working directory"""
    current_dir = Path.cwd()
    
    # Get the project root directory ID
    project_markers = ['.git', 'package.json', 'requirements.txt', 'pyproject.toml', '.env']
    project_root = current_dir
    
    # Search upwards for the project root directory
    for marker in project_markers:
        if (current_dir / marker).exists():
            project_root = current_dir
            break
        else:
            # Traverse the parent directory upwards
            for parent in current_dir.parents:
                if (parent / marker).exists():
                    project_root = parent
                    break
    
    return {
        'current_dir': str(current_dir),
        'project_root': str(project_root),
        'project_name': project_root.name,
        'sync_time': datetime.now().isoformat()
    }

def find_matching_sessions(working_dir_info):
    """Find matching sessions in the global session directory"""
    matching_sessions = []
    
    if not KIMI_SESSIONS_DIR.exists():
        return matching_sessions
    
    # Traverse all session directories
    for session_dir in KIMI_SESSIONS_DIR.iterdir():
        if not session_dir.is_dir():
            continue
            
        # Check if the session belongs to the current project
        for jsonl_file in session_dir.glob("*.jsonl"):
            try:
                with open(jsonl_file, 'r', encoding='utf-8') as f:
                    content = f.read()
                    
                    # Check whether the current working directory path is included
                    if working_dir_info['current_dir'] in content or working_dir_info['project_root'] in content:
                        matching_sessions.append({
                            'session_id': session_dir.name,
                            'jsonl_file': jsonl_file.name,
                            'file_path': str(jsonl_file),
                            'last_modified': jsonl_file.stat().st_mtime,
                            'file_size': jsonl_file.stat().st_size
                        })
                        break
            except Exception as e:
                continue
    
    return matching_sessions

# Get working directory information
working_info = get_working_dir_info()
print(f"📂 Current working directory: {working_info['current_dir']}")
print(f"🏠 Project root directory: {working_info['project_root']}")

# Find matching sessions
matching_sessions = find_matching_sessions(working_info)
print(f"🔍 Found {len(matching_sessions)} matching sessions")

Step 5: Implement subcommand function

Case A: sync - synchronize session data (default)

if subcommand == "sync":
    print(f"\n{'='*60}")
    print("🔄 Start synchronizing session data...")
    print(f"{'='*60}")
    
    if not matching_sessions:
        print("⚠️ No session related to the current project found")
        print("\n💡 Tip:")
        print("- Make sure you have used Kimi CLI in the current directory")
        print("- Check whether data exists in the global session directory")
        print("- Use the 'list' subcommand to view all sessions")
        exit(0)
    
    # Sort by modification time, latest first
    matching_sessions.sort(key=lambda x: x['last_modified'], reverse=True)
    
    # Synchronize the latest session
    sync_count = 0
    for session in matching_sessions[:3]: # Synchronize the latest 3 sessions
        try:
            src_file = Path(session['file_path'])
            dst_file = CURRENT_SESSION_DIR / f"{session['session_id']}_{session['jsonl_file']}"
            
            # Copy files
            shutil.copy2(src_file, dst_file)
            sync_count += 1
            
            print(f"✅ Synced: {session['session_id']}")
            print(f" file: {session['jsonl_file']}")
            print(f" size: {session['file_size']} bytes")
            print(f" time: {datetime.fromtimestamp(session['last_modified']).strftime('%Y-%m-%d %H:%M:%S')}")
            
        except Exception as e:
            print(f"❌ Synchronization failed: {session['session_id']} - {str(e)}")
    
    # Record current session information
    session_info = {
        'sync_time': working_info['sync_time'],
        'working_dir': working_info['current_dir'],
        'project_root': working_info['project_root'],
        'project_name': working_info['project_name'],
        'synced_sessions': [
            {
                'session_id': s['session_id'],
                'file': s['jsonl_file'],
                'last_modified': s['last_modified']
            } for s in matching_sessions[:3]
        ],
        'total_synced': sync_count
    }
    
    # Save session information to file
    with open(CURRENT_SESSION_INFO, 'w', encoding='utf-8') as f:
        json.dump(session_info, f, ensure_ascii=False, indent=2)
    
    print(f"\n{'='*60}")
    print(f"✅ Sync completed! Synced {sync_count} sessions together")
    print(f"📄 Session information has been saved to: {CURRENT_SESSION_INFO}")
    print(f"📁 The synchronized file is saved in: {CURRENT_SESSION_DIR}")
    print(f"{'='*60}")

Case B: list - List syncable sessions

elif subcommand == "list":
    print(f"\n{'='*60}")
    print("📋 Synchronizable conversation list")
    print(f"{'='*60}")
    
    if not matching_sessions:
        print("⚠️ No session related to the current project found")
        print("\n💡 Tip:")
        print("- Make sure you have used Kimi CLI in the current directory")
        print("- Check whether data exists in the global session directory")
        exit(0)
    
    # Sort by modification time
    matching_sessions.sort(key=lambda x: x['last_modified'], reverse=True)
    
    for i, session in enumerate(matching_sessions, 1):
        print(f"\n{i}. **session ID**: `{session['session_id']}`")
        print(f" **session file**: {session['jsonl_file']}")
        print(f" **File size**: {session['file_size']} bytes")
        print(f" **Last modified**: {datetime.fromtimestamp(session['last_modified']).strftime('%Y-%m-%d %H:%M:%S')}")
        
        # Check if synchronized
        synced_file = CURRENT_SESSION_DIR / f"{session['session_id']}_{session['jsonl_file']}"
        if synced_file.exists():
            print(f" **Synchronization status**: ✅ Synced")
        else:
            print(f" **Synchronization status**: ⏳ Not synchronized")
    
    print(f"\n{'='*60}")
    print(f"💡 **Instructions**:")
    print(f"- Synchronize all sessions using the 'sync' subcommand")
    print(f"- Use 'show <session_id>' to view session details")
    print(f"- Use 'clear' to clear locally synchronized sessions")
    print(f"{'='*60}")

Case C: show <session_id> - Show session details

elif subcommand == "show":
    if not param:
        print("❌ Please provide session ID")
        print("Usage: /kimi.session show <session_id>")
        exit(1)
    
    session_id = param.strip()
    
    # Find matching sessions
    target_session = None
    for session in matching_sessions:
        if session['session_id'] == session_id:
            target_session = session
            break
    
    if not target_session:
        print(f"❌ Session not found: {session_id}")
        print("💡 Use the 'list' subcommand to view all available sessions")
        exit(1)
    
    print(f"\n{'='*60}")
    print(f"📋 Session details: {session_id}")
    print(f"{'='*60}")
    
    # Read the conversation content for analysis
    jsonl_file = Path(target_session['file_path'])
    try:
        with open(jsonl_file, 'r', encoding='utf-8') as f:
            lines = f.readlines()
            
        # Analyze conversation content
        user_messages = 0
        assistant_messages = 0
        first_message_time = None
        last_message_time = None
        
        for line in lines:
            try:
                data = json.loads(line)
                role = data.get('role', '')
                
                if role == 'user':
                    user_messages += 1
                elif role == 'assistant':
                    assistant_messages += 1
                
                # Get time information
                create_time = data.get('create_time')
                if create_time:
                    if not first_message_time:
                        first_message_time = create_time
                    last_message_time = create_time
            except:
                continue
        
        print(f"**session file**: {target_session['jsonl_file']}")
        print(f"**File size**: {target_session['file_size']} bytes")
        print(f"**Last modified**: {datetime.fromtimestamp(target_session['last_modified']).strftime('%Y-%m-%d %H:%M:%S')}")
        print(f"**User messages**: {user_messages}")
        print(f"**Assistant messages**: {assistant_messages}")
        print(f"**Total number of messages**: {user_messages + assistant_messages}")
        
        if first_message_time and last_message_time:
            print(f"**Conversation time**: {first_message_time} - {last_message_time}")
        
        # Display summary of recent messages
        print(f"\n{'='*60}")
        print("Summary of recent conversations:")
        print(f"{'='*60}")
        
        recent_lines = lines[-10:] if len(lines) > 10 else lines
        for line in recent_lines:
            try:
                data = json.loads(line)
                role = data.get('role', '')
                content = data.get('content', '')
                
                if isinstance(content, list) and content:
                    text = content[0].get('text', '') if isinstance(content[0], dict) else str(content[0])
                else:
                    text = str(content)
                
                # Clean up text
                text = text.strip()
                if text:
                    #Truncate text that is too long
                    if len(text) > 150:
                        text = text[:150] + "..."
                    
                    role_emoji = "👤" if role == 'user' else "🤖"
                    print(f"{role_emoji} {text}")
                    
            except:
                continue
        
        print(f"\n{'='*60}")
        print(f"💡 **Operation options**:")
        print(f"- Use 'sync' to synchronize this session to local")
        print(f"-Resume this session using 'resume {session_id}'")
        print(f"{'='*60}")
        
    except Exception as e:
        print(f"❌ Failed to read session file: {str(e)}")

Case D: clear - clear the local synchronized session

elif subcommand == "clear":
    print(f"\n{'='*60}")
    print("🗑️ Clean up local synchronized sessions...")
    print(f"{'='*60}")
    
    # Check if there are synchronized files
    synced_files = list(CURRENT_SESSION_DIR.glob("*.jsonl"))
    
    if not synced_files:
        print("⚠️ No local synchronized session file found")
        exit(0)
    
    print(f"📊 Found {len(synced_files)} synchronized session files")
    
    # Display files to be deleted
    for i, file in enumerate(synced_files, 1):
        print(f"{i}. {file.name} ({file.stat().st_size} bytes)")
    
    # Delete files
    deleted_count = 0
    for file in synced_files:
        try:
            file.unlink()
            deleted_count += 1
        except Exception as e:
            print(f"❌ Delete failed: {file.name} - {str(e)}")
    
    # Clean session information files
    if CURRENT_SESSION_INFO.exists():
        try:
            CURRENT_SESSION_INFO.unlink()
        except:
            pass
    
    print(f"\n✅ Cleanup completed! {deleted_count} files deleted")
    print(f"📁 The local session directory has been cleared: {CURRENT_SESSION_DIR}")

Case E: status - Display synchronization status

elif subcommand == "status":
    print(f"\n{'='*60}")
    print("📊 Session synchronization status")
    print(f"{'='*60}")
    
    # Check current session information
    if CURRENT_SESSION_INFO.exists():
        try:
            with open(CURRENT_SESSION_INFO, 'r', encoding='utf-8') as f:
                session_info = json.load(f)
            
            print(f"**Last synchronization time**: {session_info.get('sync_time', 'Unknown')}")
            print(f"**working directory**: {session_info.get('working_dir', 'unknown')}")
            print(f"**Project name**: {session_info.get('project_name', 'Unknown')}")
            print(f"**Number of synchronized sessions**: {session_info.get('total_synced', 0)}")
            
            synced_sessions = session_info.get('synced_sessions', [])
            if synced_sessions:
                print(f"\n**Synced session**:")
                for i, session in enumerate(synced_sessions, 1):
                    print(f"{i}. {session['session_id']} - {session['file']}")
            
        except Exception as e:
            print(f"❌ Failed to read session information: {str(e)}")
    else:
        print("⚠️ Session synchronization has not been performed yet")
    
    # Check locally synchronized files
    synced_files = list(CURRENT_SESSION_DIR.glob("*.jsonl"))
    print(f"\n**Local synchronized files**: {len(synced_files)}")
    
    if synced_files:
        total_size = sum(f.stat().st_size for f in synced_files)
        print(f"**Total size**: {total_size} bytes")
        
        print(f"\n**File list**:")
        for file in synced_files:
            print(f"- {file.name} ({file.stat().st_size} bytes)")
    
    print(f"\n{'='*60}")

Default: Show help

else:
    print(f"❌ Unknown subcommand: {subcommand}")
    print(f"\n{'='*60}")
    print("📖 Available subcommands:")
    print("- `sync` - synchronize session data (default)")
    print("- `list` - List of sessions that can be synchronized")
    print("- `show <session_id>` - show session details")
    print("- `clear` - clear local synchronized session")
    print("- `status` - displays synchronization status")
    print(f"{'='*60}")
    print("💡 Example:")
    print(" /kimi.session sync")
    print(" /kimi.session list")
    print("/kimi.session show dcc1f6970f1ebea26417a3b8398655ce")
    print(" /kimi.session clear")
    print(" /kimi.session status")
    print(f"{'='*60}")

Execution Complete ✅

This command provides complete session data synchronization capabilities and can:

Automatically identify sessions related to the current project
Synchronize session data to local project directory
Manage and view sync status
Clean up locally synchronized data
Provide data foundation for session recovery function

resume chat #213

Description

What feature would you like to see?

Additional information

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions