@agentunion/kite 1.3.1 → 1.4.0

package/launcher/logging_setup.py

@@ -50,6 +50,9 @@ def init_log_files():
     _log_dir = os.path.join(module_data, "log")
     os.makedirs(_log_dir, exist_ok=True)
 
+    # Clean up orphaned instance log files before initializing
+    _cleanup_orphaned_logs()
+
     suffix = os.environ.get("KITE_INSTANCE_SUFFIX", "")
 
     # latest.log — truncate on each startup
@@ -73,6 +76,107 @@ def init_log_files():
     _resolve_daily_log_path()
 
 
+def _cleanup_orphaned_logs():
+    """Clean up log files from dead instances (files with ~N suffix whose launcher is not running)."""
+    if not _log_dir or not os.path.isdir(_log_dir):
+        return
+
+    try:
+        # Get state directory path
+        module_data = os.environ.get("KITE_MODULE_DATA")
+        if not module_data:
+            return
+        state_dir = os.path.join(os.path.dirname(module_data), "state")
+
+        # Scan for files with ~N suffix
+        import glob
+        orphaned_files = []
+
+        for pattern in ["latest~*.log", "crashes~*.jsonl"]:
+            for filepath in glob.glob(os.path.join(_log_dir, pattern)):
+                basename = os.path.basename(filepath)
+                # Extract instance number from filename
+                instance_num = _extract_instance_num(basename)
+                if instance_num is None:
+                    continue
+
+                # Check if corresponding launcher is still running
+                if not _is_instance_alive(state_dir, instance_num):
+                    orphaned_files.append(filepath)
+
+        # Delete orphaned files
+        if orphaned_files:
+            _builtin_print(f"[launcher] 清理 {len(orphaned_files)} 个孤儿日志文件:")
+            for filepath in orphaned_files:
+                try:
+                    os.remove(filepath)
+                    _builtin_print(f"[launcher]   已删除: {os.path.basename(filepath)}")
+                except Exception as e:
+                    _builtin_print(f"[launcher]   删除失败 {os.path.basename(filepath)}: {e}")
+
+    except Exception as e:
+        _builtin_print(f"[launcher] 清理孤儿日志文件时出错: {e}")
+
+
+def _extract_instance_num(filename: str) -> int | None:
+    """Extract instance number from log filename. Returns None if not a valid instance file."""
+    import re
+    # Match patterns like "latest~2.log" or "crashes~3.jsonl"
+    m = re.match(r"^(?:latest|crashes)~(\d+)\.(log|jsonl)$", filename)
+    return int(m.group(1)) if m else None
+
+
+def _is_instance_alive(state_dir: str, instance_num: int) -> bool:
+    """Check if a launcher instance is still running by checking its processes file and PID."""
+    if not os.path.isdir(state_dir):
+        return False
+
+    # Determine processes filename
+    if instance_num == 1:
+        processes_file = os.path.join(state_dir, "processes.json")
+    else:
+        processes_file = os.path.join(state_dir, f"processes~{instance_num}.json")
+
+    # If processes file doesn't exist, instance is dead
+    if not os.path.isfile(processes_file):
+        return False
+
+    # Read launcher_pid from processes file
+    try:
+        import json
+        with open(processes_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        launcher_pid = data.get("launcher_pid")
+        if not launcher_pid:
+            return False
+
+        # Check if process is still running
+        return _is_process_running(launcher_pid)
+    except Exception:
+        return False
+
+
+def _is_process_running(pid: int) -> bool:
+    """Check if a process with given PID is running (cross-platform)."""
+    try:
+        if sys.platform == "win32":
+            # Windows: use tasklist
+            import subprocess
+            result = subprocess.run(
+                ["tasklist", "/FI", f"PID eq {pid}", "/NH"],
+                capture_output=True,
+                text=True,
+                timeout=2
+            )
+            return str(pid) in result.stdout
+        else:
+            # Unix: send signal 0
+            os.kill(pid, 0)
+            return True
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+
+
 def _resolve_daily_log_path():
     """Resolve the daily log file path based on current date."""
     global _log_daily_path, _log_daily_date

package/launcher/module.md

@@ -1,37 +1,37 @@
----
-name: launcher
-display_name: "Launcher"
-version: "1.0"
-type: infrastructure
-state: enabled
-events:
-  - module.started
-  - module.stopped
-  - module.state_changed
-subscriptions: []
-discovery:
-  test_modules:
-    type: scan_dir
-    path: test_modules
-    enabled: true
----
-
-# Launcher
-
-Kite 系统的启动器和进程管理器。与 main.py 在同一进程中运行，是整个系统的入口和控制台。
-
-## 职责
-
-- 启动 Registry，等待就绪
-- 扫描 core/ 和 extensions/ 下的模块
-- 并行启动 state: enabled 的模块
-- 监控子进程状态，core 模块崩溃触发全量重启
-- 提供 Launcher API 供其他模块启停管理
-- 优雅退出时清理所有子进程
-
-## API
-
-- `GET /launcher/modules` — 列出所有模块及状态
-- `POST /launcher/modules/{name}/start` — 启动模块
-- `POST /launcher/modules/{name}/stop` — 停止模块
-- `PUT /launcher/modules/{name}/state` — 修改模块 state
+---
+name: launcher
+display_name: Launcher
+version: '1.0'
+type: infrastructure
+state: enabled
+events:
+- module.started
+- module.stopped
+- module.state_changed
+subscriptions: []
+discovery:
+  test_modules:
+    type: scan_dir
+    path: test_modules
+    enabled: true
+monitor: true
+---
+# Launcher
+
+Kite 系统的启动器和进程管理器。与 main.py 在同一进程中运行，是整个系统的入口和控制台。
+
+## 职责
+
+- 启动 Registry，等待就绪
+- 扫描 core/ 和 extensions/ 下的模块
+- 并行启动 state: enabled 的模块
+- 监控子进程状态，core 模块崩溃触发全量重启
+- 提供 Launcher API 供其他模块启停管理
+- 优雅退出时清理所有子进程
+
+## API
+
+- `GET /launcher/modules` — 列出所有模块及状态
+- `POST /launcher/modules/{name}/start` — 启动模块
+- `POST /launcher/modules/{name}/stop` — 停止模块
+- `PUT /launcher/modules/{name}/state` — 修改模块 state

package/launcher/process_manager.py

@@ -327,8 +327,19 @@ class ProcessManager:
             return 0
 
         # Dead launcher (or old format) — clean up its child processes
+        # Sort: watchdog first, kernel last, others in middle (prevents cascading issues)
+        def _cleanup_sort_key(entry):
+            name = entry.get("name", "")
+            if name == "watchdog":
+                return (0, name)
+            if name == "kernel":
+                return (2, name)
+            return (1, name)
+
+        records_sorted = sorted(records, key=_cleanup_sort_key)
+
         killed = 0
-        for entry in records:
+        for entry in records_sorted:
             pid = entry.get("pid", 0)
             cmd = entry.get("cmd", [])
             name = entry.get("name", "?")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentunion/kite",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Kite framework launcher — start Kite from anywhere",
   "bin": {
     "kite": "./cli.js"
@@ -11,6 +11,7 @@
     "launcher/**",
     "kernel/**",
     "extensions/**",
+    "kite_cli/**",
     "scripts/**",
     "CHANGELOG.md",
     "!**/__pycache__",

package/scripts/plan_manager.py

@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+"""Kite CLI 开发计划管理器
+
+用于管理开发计划的进度、状态和任务分配。
+"""
+import json
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict, Optional
+
+
+class PlanManager:
+    """开发计划管理器"""
+
+    def __init__(self, plan_file: str = None):
+        if plan_file is None:
+            plan_file = Path(__file__).parent.parent / "docs" / "CLI开发计划.md"
+        self.plan_file = Path(plan_file)
+        self.state_file = self.plan_file.parent / ".cli_plan_state.json"
+        self.state = self._load_state()
+
+    def _load_state(self) -> Dict:
+        """加载计划状态"""
+        if self.state_file.exists():
+            with open(self.state_file, "r", encoding="utf-8") as f:
+                return json.load(f)
+        return {
+            "tasks": {},
+            "history": []
+        }
+
+    def _save_state(self):
+        """保存计划状态"""
+        with open(self.state_file, "w", encoding="utf-8") as f:
+            json.dump(self.state, f, indent=2, ensure_ascii=False)
+
+    def list_tasks(self, phase: Optional[str] = None, status: Optional[str] = None):
+        """列出任务"""
+        content = self.plan_file.read_text(encoding="utf-8")
+
+        # 解析任务
+        tasks = []
+        current_phase = None
+        current_section = None
+
+        for line in content.split("\n"):
+            # 检测 Phase
+            phase_match = re.match(r"## (Phase \d+):", line)
+            if phase_match:
+                current_phase = phase_match.group(1)
+                continue
+
+            # 检测子任务
+            section_match = re.match(r"### ([\d.]+) (.+)", line)
+            if section_match:
+                task_id = section_match.group(1)
+                task_name = section_match.group(2)
+                current_section = f"{current_phase}.{task_id}"
+
+                # 获取状态
+                task_state = self.state["tasks"].get(current_section, {})
+                task_status = task_state.get("status", "待开始")
+
+                tasks.append({
+                    "id": current_section,
+                    "phase": current_phase,
+                    "name": task_name,
+                    "status": task_status,
+                    "assignee": task_state.get("assignee"),
+                    "started_at": task_state.get("started_at"),
+                    "completed_at": task_state.get("completed_at")
+                })
+
+        # 过滤
+        if phase:
+            tasks = [t for t in tasks if t["phase"] == phase]
+        if status:
+            tasks = [t for t in tasks if t["status"] == status]
+
+        return tasks
+
+    def show_tasks(self, phase: Optional[str] = None, status: Optional[str] = None):
+        """显示任务列表"""
+        tasks = self.list_tasks(phase, status)
+
+        if not tasks:
+            print("没有找到任务")
+            return
+
+        print(f"\n{'ID':<20} {'任务名称':<30} {'状态':<10} {'负责人':<10}")
+        print("-" * 80)
+
+        for task in tasks:
+            task_id = task["id"]
+            name = task["name"][:28] + ".." if len(task["name"]) > 30 else task["name"]
+            status_str = task["status"]
+            assignee = task["assignee"] or "-"
+
+            print(f"{task_id:<20} {name:<30} {status_str:<10} {assignee:<10}")
+
+        print(f"\n共 {len(tasks)} 个任务")
+
+    def start_task(self, task_id: str, assignee: str = "开发者"):
+        """开始任务"""
+        if task_id not in self.state["tasks"]:
+            self.state["tasks"][task_id] = {}
+
+        self.state["tasks"][task_id].update({
+            "status": "进行中",
+            "assignee": assignee,
+            "started_at": datetime.now().isoformat()
+        })
+
+        self.state["history"].append({
+            "action": "start",
+            "task_id": task_id,
+            "assignee": assignee,
+            "timestamp": datetime.now().isoformat()
+        })
+
+        self._save_state()
+        print(f"[Done] 任务 {task_id} 已开始")
+
+    def complete_task(self, task_id: str, note: str = None):
+        """完成任务"""
+        if task_id not in self.state["tasks"]:
+            print(f"[Error] 任务 {task_id} 不存在")
+            return
+
+        self.state["tasks"][task_id].update({
+            "status": "已完成",
+            "completed_at": datetime.now().isoformat(),
+            "note": note
+        })
+
+        self.state["history"].append({
+            "action": "complete",
+            "task_id": task_id,
+            "note": note,
+            "timestamp": datetime.now().isoformat()
+        })
+
+        self._save_state()
+        print(f"[Done] 任务 {task_id} 已完成")
+
+    def block_task(self, task_id: str, reason: str):
+        """阻塞任务"""
+        if task_id not in self.state["tasks"]:
+            self.state["tasks"][task_id] = {}
+
+        self.state["tasks"][task_id].update({
+            "status": "阻塞",
+            "blocked_reason": reason,
+            "blocked_at": datetime.now().isoformat()
+        })
+
+        self.state["history"].append({
+            "action": "block",
+            "task_id": task_id,
+            "reason": reason,
+            "timestamp": datetime.now().isoformat()
+        })
+
+        self._save_state()
+        print(f"[Warning] 任务 {task_id} 已阻塞: {reason}")
+
+    def unblock_task(self, task_id: str):
+        """解除阻塞"""
+        if task_id not in self.state["tasks"]:
+            print(f"[Error] 任务 {task_id} 不存在")
+            return
+
+        self.state["tasks"][task_id].update({
+            "status": "进行中",
+            "blocked_reason": None,
+            "unblocked_at": datetime.now().isoformat()
+        })
+
+        self.state["history"].append({
+            "action": "unblock",
+            "task_id": task_id,
+            "timestamp": datetime.now().isoformat()
+        })
+
+        self._save_state()
+        print(f"[Done] 任务 {task_id} 已解除阻塞")
+
+    def show_progress(self):
+        """显示整体进度"""
+        tasks = self.list_tasks()
+
+        total = len(tasks)
+        completed = len([t for t in tasks if t["status"] == "已完成"])
+        in_progress = len([t for t in tasks if t["status"] == "进行中"])
+        blocked = len([t for t in tasks if t["status"] == "阻塞"])
+        pending = total - completed - in_progress - blocked
+
+        print("\n=== Kite CLI 开发进度 ===\n")
+        print(f"总任务数: {total}")
+        print(f"已完成:   {completed} ({completed/total*100:.1f}%)")
+        print(f"进行中:   {in_progress} ({in_progress/total*100:.1f}%)")
+        print(f"阻塞:     {blocked} ({blocked/total*100:.1f}%)")
+        print(f"待开始:   {pending} ({pending/total*100:.1f}%)")
+
+        # 按 Phase 统计
+        print("\n=== 各阶段进度 ===\n")
+        phases = {}
+        for task in tasks:
+            phase = task["phase"]
+            if phase not in phases:
+                phases[phase] = {"total": 0, "completed": 0}
+            phases[phase]["total"] += 1
+            if task["status"] == "已完成":
+                phases[phase]["completed"] += 1
+
+        for phase, stats in sorted(phases.items()):
+            total_p = stats["total"]
+            completed_p = stats["completed"]
+            percent = completed_p / total_p * 100 if total_p > 0 else 0
+            print(f"{phase}: {completed_p}/{total_p} ({percent:.1f}%)")
+
+    def show_history(self, limit: int = 10):
+        """显示操作历史"""
+        history = self.state["history"][-limit:]
+
+        if not history:
+            print("暂无操作历史")
+            return
+
+        print(f"\n最近 {len(history)} 条操作:\n")
+
+        for entry in history:
+            timestamp = entry["timestamp"][:19]
+            action = entry["action"]
+            task_id = entry["task_id"]
+
+            action_map = {
+                "start": "开始",
+                "complete": "完成",
+                "block": "阻塞",
+                "unblock": "解除阻塞"
+            }
+
+            action_str = action_map.get(action, action)
+            print(f"{timestamp} - {action_str} {task_id}")
+
+            if action == "complete" and entry.get("note"):
+                print(f"           备注: {entry['note']}")
+            elif action == "block" and entry.get("reason"):
+                print(f"           原因: {entry['reason']}")
+
+
+def main():
+    """命令行入口"""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Kite CLI 开发计划管理器")
+    subparsers = parser.add_subparsers(dest="command", help="命令")
+
+    # list 命令
+    list_parser = subparsers.add_parser("list", help="列出任务")
+    list_parser.add_argument("--phase", help="过滤 Phase")
+    list_parser.add_argument("--status", help="过滤状态")
+
+    # start 命令
+    start_parser = subparsers.add_parser("start", help="开始任务")
+    start_parser.add_argument("task_id", help="任务 ID")
+    start_parser.add_argument("--assignee", default="开发者", help="负责人")
+
+    # complete 命令
+    complete_parser = subparsers.add_parser("complete", help="完成任务")
+    complete_parser.add_argument("task_id", help="任务 ID")
+    complete_parser.add_argument("--note", help="备注")
+
+    # block 命令
+    block_parser = subparsers.add_parser("block", help="阻塞任务")
+    block_parser.add_argument("task_id", help="任务 ID")
+    block_parser.add_argument("reason", help="阻塞原因")
+
+    # unblock 命令
+    unblock_parser = subparsers.add_parser("unblock", help="解除阻塞")
+    unblock_parser.add_argument("task_id", help="任务 ID")
+
+    # progress 命令
+    progress_parser = subparsers.add_parser("progress", help="显示进度")
+
+    # history 命令
+    history_parser = subparsers.add_parser("history", help="显示历史")
+    history_parser.add_argument("--limit", type=int, default=10, help="显示条数")
+
+    args = parser.parse_args()
+
+    manager = PlanManager()
+
+    if args.command == "list":
+        manager.show_tasks(phase=args.phase, status=args.status)
+    elif args.command == "start":
+        manager.start_task(args.task_id, args.assignee)
+    elif args.command == "complete":
+        manager.complete_task(args.task_id, args.note)
+    elif args.command == "block":
+        manager.block_task(args.task_id, args.reason)
+    elif args.command == "unblock":
+        manager.unblock_task(args.task_id)
+    elif args.command == "progress":
+        manager.show_progress()
+    elif args.command == "history":
+        manager.show_history(args.limit)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()