monoco-toolkit 0.1.1__py3-none-any.whl → 0.2.5__py3-none-any.whl

monoco/features/issue/resources/en/AGENTS.md

@@ -0,0 +1,15 @@
+# Issue Management (Agent Guidance)
+
+## Issue Management
+
+System for managing tasks using `monoco issue`.
+
+- **Create**: `monoco issue create <type> -t "Title"` (types: epic, feature, chore, fix)
+- **Status**: `monoco issue open|close|backlog <id>`
+- **Check**: `monoco issue lint` (Must run after manual edits)
+- **Lifecycle**: `monoco issue start|submit|delete <id>`
+- **Structure**: `Issues/{CapitalizedPluralType}/{lowercase_status}/` (e.g. `Issues/Features/open/`). Do not deviate.
+- **Rules**:
+  1. **Heading**: Must have `## {ID}: {Title}` (matches metadata).
+  2. **Checkboxes**: Min 2 using `- [ ]`, `- [x]`, `- [-]`, `- [/]`.
+  3. **Review**: `## Review Comments` section required for Review/Done stages.

monoco/features/issue/resources/en/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: monoco-issue
+description: Official skill for Monoco Issue System. Treats Issues as Universal Atoms, managing the lifecycle of Epic/Feature/Chore/Fix.
+---
+
+# Issue Management
+
+Use this skill to create and manage **Issues** (Universal Atoms) in Monoco projects.
+
+## Core Ontology
+
+### 1. Strategy Layer
+
+- **🏆 EPIC**: Grand goals, vision containers. Mindset: Architect.
+
+### 2. Value Layer
+
+- **✨ FEATURE**: Value increments from user perspective. Mindset: Product Owner.
+- **Atomicity Principle**: Feature = Design + Dev + Test + Doc + i18n. They are one.
+
+### 3. Execution Layer
+
+- **🧹 CHORE**: Engineering maintenance, no direct user value. Mindset: Builder.
+- **🐞 FIX**: Correcting deviations. Mindset: Debugger.
+
+## Guidelines
+
+### Directory Structure & Naming
+
+`Issues/{CapitalizedPluralType}/{lowercase_status}/`
+
+- **Types**: `Epics`, `Features`, `Chores`, `Fixes`
+- **Statuses**: `open`, `backlog`, `closed`
+
+### Structural Integrity
+
+Issues are validated via `monoco issue lint`. key constraints:
+
+1. **Mandatory Heading**: `## {ID}: {Title}` must match front matter.
+2. **Min Checkboxes**: At least 2 checkboxes (AC/Tasks).
+3. **Review Protocol**: `## Review Comments` required for `review` or `done` stages.
+
+### Path Transitions
+
+Use `monoco issue`:
+
+1. **Create**: `monoco issue create <type> --title "..."`
+
+   - Params: `--parent <id>`, `--dependency <id>`, `--related <id>`, `--sprint <id>`, `--tags <tag>`
+
+2. **Transition**: `monoco issue open/close/backlog <id>`
+
+3. **View**: `monoco issue scope`
+
+4. **Validation**: `monoco issue lint`
+
+5. **Modification**: `monoco issue start/submit/delete <id>`
+
+6. **Commit**: `monoco issue commit` (Atomic commit for issue files)
+7. **Validation**: `monoco issue lint` (Enforces compliance)
+
+## Validation Rules (FEAT-0082)
+
+To ensure data integrity, all Issue tickets must follow these strict rules:
+
+### 1. Structural Consistency
+
+- Must contain a Level 2 Heading matching exactly: `## {ID}: {Title}`.
+- Example: `## FEAT-0082: Issue Ticket Validator`
+
+### 2. Content Completeness
+
+- **Checkboxes**: Minimum of 2 checkboxes required (one for AC, one for Tasks).
+- **Review Comments**: If `stage` is `review` or `done`, a `## Review Comments` section is mandatory and must not be empty.
+
+### 3. Checkbox Syntax & Hierarchy
+
+- Use only `- [ ]`, `- [x]`, `- [-]`, or `- [/]`.
+- **Inheritance**: If nested checkboxes exist, the parent state must reflect child states (e.g., if any child is `[/]`, parent must be `[/]`; if all children are `[x]`, parent must be `[x]`).
+
+### 4. State Matrix
+
+The `status` (folder) and `stage` (front matter) must be compatible:
+
+- **open**: Draft, Doing, Review, Done
+- **backlog**: Draft, Doing, Review
+- **closed**: Done

monoco/features/issue/resources/zh/AGENTS.md

@@ -0,0 +1,15 @@
+# Issue 管理 (Agent 指引)
+
+## Issue 管理
+
+使用 `monoco issue` 管理任务的系统。
+
+- **创建**: `monoco issue create <type> -t "标题"` (类型: epic, feature, chore, fix)
+- **状态**: `monoco issue open|close|backlog <id>`
+- **检查**: `monoco issue lint` (手动编辑后必须运行)
+- **生命周期**: `monoco issue start|submit|delete <id>`
+- **结构**: `Issues/{CapitalizedPluralType}/{lowercase_status}/` (如 `Issues/Features/open/`)。
+- **强制规则**:
+  1. **标题**: 必须包含 `## {ID}: {Title}` 标题（与 Front Matter 一致）。
+  2. **内容**: 至少 2 个 Checkbox，使用 `- [ ]`, `- [x]`, `- [-]`, `- [/]`。
+  3. **评审**: `review`/`done` 阶段必须包含 `## Review Comments` 章节且内容不为空。

monoco/features/issue/resources/zh/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: monoco-issue
+description: Monoco Issue System 的官方技能定义。将 Issue 视为通用原子 (Universal Atom)，管理 Epic/Feature/Chore/Fix 的生命周期。
+---
+
+# 自我管理 (Monoco Issue System)
+
+使用此技能在 Monoco 项目中创建和管理 **Issue** (通用原子)。该系统参考 Jira 表达体系，同时保持 "建设者 (Builder)" 和 "调试者 (Debugger)" 思维模式的隔离。
+
+## 核心本体论 (Core Ontology)
+
+Monoco 不仅仅复刻 Jira，而是基于 **"思维模式 (Mindset)"** 重新定义工作单元。
+
+### 1. 战略层 (Strategy)
+
+#### 🏆 EPIC (史诗)
+
+- **Mindset**: _Architect_ (架构师)
+- **定义**: 跨越多个周期的宏大目标。它不是单纯的"大任务"，而是"愿景的容器"。
+- **产出**: 定义了系统的边界和核心价值。
+
+### 2. 价值层 (Value)
+
+#### ✨ FEATURE (特性)
+
+- **Mindset**: _Product Owner_ (产品负责人)
+- **定义**: 用户视角的价值增量。必须是可独立交付 (Shippable) 的垂直切片。
+- **Focus**: "Why" & "What" (用户想要什么？)。
+- **Prefix**: `FEAT-`
+
+### 3. 执行层 (Execution)
+
+#### 🧹 CHORE (杂务)
+
+- **Mindset**: _Builder_ (建设者)
+- **定义**: **不产生**直接用户价值的工程性事务。
+- **场景**: 架构升级、写构建脚本、修复 CI/CD 流水线。
+- **Focus**: "How" (为了支撑系统运转，必须做什么)。
+- **Prefix**: `CHORE-`
+
+> 注：取代了传统的 Task 概念。
+
+#### 🐞 FIX (修复)
+
+- **Mindset**: _Debugger_ (调试者)
+- **定义**: 预期与现实的偏差。它是负价值的修正。
+- **Focus**: "Fix" (恢复原状)。
+- **Prefix**: `FIX-`
+
+> 注：取代了传统的 Bug 概念。
+
+---
+
+**关系链**:
+
+- **主要**: `EPIC` (愿景) -> `FEATURE` (价值交付单元)
+- **次要**: `CHORE` (工程维护/支撑) - 通常独立存在。
+- **原子性原则**: Feature = Design + Dev + Test + Doc + i18n。它们是一体的。
+
+## 准则 (Guidelines)
+
+### 目录结构
+
+`Issues/{CapitalizedPluralType}/{lowercase_status}/`
+
+- `{TYPE}`: `Epics`, `Features`, `Chores`, `Fixes`
+- `{STATUS}`: `open`, `backlog`, `closed`
+
+### 路径流转
+
+使用 `monoco issue`：
+
+1. **Create**: `monoco issue create <type> --title "..."`
+
+   - Params: `--parent <id>`, `--dependency <id>`, `--related <id>`, `--sprint <id>`, `--tags <tag>`
+
+2. **Transition**: `monoco issue open/close/backlog <id>`
+
+3. **View**: `monoco issue scope`
+
+4. **Validation**: `monoco issue lint`
+
+5. **Modification**: `monoco issue start/submit/delete <id>`
+
+6. **Commit**: `monoco issue commit` (原子化提交 Issue 文件)
+7. **Validation**: `monoco issue lint` (强制执行合规性检查)
+
+## 合规与结构校验 (Validation Rules)
+
+为了确保数据严谨性，所有 Issue Ticket 必须遵循以下强制规则：
+
+### 1. 结构一致性 (Structural Consistency)
+
+- 必须包含一个二级标题 (`##`)，内容必须与 Front Matter 中的 ID 和 Title 严格匹配。
+- 格式：`## {ID}: {Title}`
+- 示例：`## FEAT-0082: Issue Ticket Validator`
+
+### 2. 内容完整性 (Content Completeness)
+
+- **Checkbox 数量**: 每个 Ticket 必须包含至少 2 个 Checkbox（通常代表 AC 和 Tasks）。
+- **评审记录**: 当 `stage` 为 `review` 或 `done` 时，必须包含 `## Review Comments` 标题且内容不能为空。
+
+### 3. Checkbox 语法与层级 (Checkbox Matrix)
+
+- 仅限使用: `- [ ]`, `- [x]`, `- [-]`, `- [/]`。
+- **层级继承**: 若存在嵌套 Checkbox，父项状态必须正确反映子项的聚合结果（例如：任一子项为 `[/]` 则父项必为 `[/]`；子项全选则父项为 `[x]`）。
+
+### 4. 状态矩阵 (State Matrix)
+
+`status` (物理存放目录) 与 `stage` (Front Matter 字段) 必须兼容：
+
+- **open**: Draft, Doing, Review, Done
+- **backlog**: Draft, Doing, Review
+- **closed**: Done

monoco/features/issue/validator.py

@@ -0,0 +1,269 @@
+import re
+import yaml
+from typing import List, Set, Optional, Dict
+from pathlib import Path
+
+from monoco.core.lsp import Diagnostic, DiagnosticSeverity, Range, Position
+from monoco.core.config import get_config
+from monoco.features.i18n.core import detect_language
+from .models import IssueMetadata, IssueStatus, IssueStage, IssueType
+
+class IssueValidator:
+    """
+    Centralized validation logic for Issue Tickets.
+    Returns LSP-compatible Diagnostics.
+    """
+    
+    def __init__(self, issue_root: Optional[Path] = None):
+        self.issue_root = issue_root
+
+    def validate(self, meta: IssueMetadata, content: str, all_issue_ids: Set[str] = set()) -> List[Diagnostic]:
+        diagnostics = []
+        
+        # 1. State Matrix Validation
+        diagnostics.extend(self._validate_state_matrix(meta, content))
+        
+        # 2. Content Completeness (Checkbox check)
+        diagnostics.extend(self._validate_content_completeness(meta, content))
+        
+        # 3. Structure Consistency (Headings)
+        diagnostics.extend(self._validate_structure(meta, content))
+        
+        # 4. Lifecycle/Integrity (Solution, etc.)
+        diagnostics.extend(self._validate_integrity(meta, content))
+        
+        # 5. Reference Integrity
+        diagnostics.extend(self._validate_references(meta, content, all_issue_ids))
+
+        # 6. Time Consistency
+        diagnostics.extend(self._validate_time_consistency(meta, content))
+
+        # 7. Checkbox Syntax
+        diagnostics.extend(self._validate_checkbox_logic(content))
+        
+        # 8. Language Consistency
+        diagnostics.extend(self._validate_language_consistency(meta, content))
+
+        return diagnostics
+
+    def _validate_language_consistency(self, meta: IssueMetadata, content: str) -> List[Diagnostic]:
+        diagnostics = []
+        try:
+            config = get_config()
+            source_lang = config.i18n.source_lang
+            
+            # Check for language mismatch (specifically zh vs en)
+            if source_lang.lower() == 'zh':
+                detected = detect_language(content)
+                if detected == 'en':
+                     diagnostics.append(self._create_diagnostic(
+                         "Language Mismatch: Project source language is 'zh' but content appears to be 'en'.",
+                         DiagnosticSeverity.Warning
+                     ))
+        except Exception:
+            pass
+        return diagnostics
+
+    def _create_diagnostic(self, message: str, severity: DiagnosticSeverity, line: int = 0) -> Diagnostic:
+        """Helper to create a diagnostic object."""
+        return Diagnostic(
+            range=Range(
+                start=Position(line=line, character=0),
+                end=Position(line=line, character=100) # Arbitrary end
+            ),
+            severity=severity,
+            message=message
+        )
+
+    def _get_field_line(self, content: str, field_name: str) -> int:
+        """Helper to find the line number of a field in the front matter."""
+        lines = content.split('\n')
+        in_fm = False
+        for i, line in enumerate(lines):
+            stripped = line.strip()
+            if stripped == "---":
+                if not in_fm:
+                    in_fm = True
+                    continue
+                else:
+                    break # End of FM
+            if in_fm:
+                # Match "field:", "field :", or "field: value"
+                if re.match(rf"^{re.escape(field_name)}\s*:", stripped):
+                    return i
+        return 0
+
+    def _validate_state_matrix(self, meta: IssueMetadata, content: str) -> List[Diagnostic]:
+        diagnostics = []
+        
+        # Check based on parsed metadata (now that auto-correction is disabled)
+        if meta.status == IssueStatus.CLOSED and meta.stage != IssueStage.DONE:
+            line = self._get_field_line(content, "status")
+            diagnostics.append(self._create_diagnostic(
+                f"State Mismatch: Closed issues must be in 'Done' stage (found: {meta.stage.value if meta.stage else 'None'})", 
+                DiagnosticSeverity.Error,
+                line=line
+            ))
+        
+        if meta.status == IssueStatus.BACKLOG and meta.stage != IssueStage.FREEZED:
+            line = self._get_field_line(content, "status")
+            diagnostics.append(self._create_diagnostic(
+                f"State Mismatch: Backlog issues must be in 'Freezed' stage (found: {meta.stage.value if meta.stage else 'None'})", 
+                DiagnosticSeverity.Error,
+                line=line
+            ))
+
+        return diagnostics
+
+    def _validate_content_completeness(self, meta: IssueMetadata, content: str) -> List[Diagnostic]:
+        diagnostics = []
+        # Checkbox regex: - [ ] or - [x] or - [-] or - [/]
+        checkboxes = re.findall(r"-\s*\[([ x\-/])\]", content)
+        
+        if len(checkboxes) < 2:
+            diagnostics.append(self._create_diagnostic(
+                "Content Incomplete: Ticket must contain at least 2 checkboxes (AC & Tasks).",
+                DiagnosticSeverity.Warning
+            ))
+            
+        if meta.stage in [IssueStage.REVIEW, IssueStage.DONE]:
+            # No empty checkboxes allowed
+            if ' ' in checkboxes:
+                # Find the first occurrence line
+                lines = content.split('\n')
+                first_line = 0
+                for i, line in enumerate(lines):
+                    if re.search(r"-\s*\[ \]", line):
+                        first_line = i
+                        break
+                        
+                diagnostics.append(self._create_diagnostic(
+                    f"Incomplete Tasks: Issue in {meta.stage} cannot have unchecked boxes.",
+                    DiagnosticSeverity.Error,
+                    line=first_line
+                ))
+        return diagnostics
+
+    def _validate_structure(self, meta: IssueMetadata, content: str) -> List[Diagnostic]:
+        diagnostics = []
+        lines = content.split('\n')
+        
+        # 1. Heading check: ## {issue-id}: {issue-title}
+        expected_header = f"## {meta.id}: {meta.title}"
+        header_found = False
+        
+        # 2. Review Comments Check
+        review_header_found = False
+        review_content_found = False
+        
+        for i, line in enumerate(lines):
+            line_stripped = line.strip()
+            if line_stripped == expected_header:
+                header_found = True
+            
+            if line_stripped == "## Review Comments":
+                review_header_found = True
+                # Check near lines for content
+                # This is a naive check (next line is not empty)
+                if i + 1 < len(lines) and lines[i+1].strip():
+                     review_content_found = True
+                elif i + 2 < len(lines) and lines[i+2].strip():
+                     review_content_found = True
+
+        if not header_found:
+             diagnostics.append(self._create_diagnostic(
+                 f"Structure Error: Missing Level 2 Heading '{expected_header}'",
+                 DiagnosticSeverity.Warning
+             ))
+             
+        if meta.stage in [IssueStage.REVIEW, IssueStage.DONE]:
+            if not review_header_found:
+                diagnostics.append(self._create_diagnostic(
+                    "Review Requirement: Missing '## Review Comments' section.",
+                    DiagnosticSeverity.Error
+                ))
+            elif not review_content_found:
+                diagnostics.append(self._create_diagnostic(
+                    "Review Requirement: '## Review Comments' section is empty.",
+                    DiagnosticSeverity.Error
+                ))
+        return diagnostics
+
+    def _validate_integrity(self, meta: IssueMetadata, content: str) -> List[Diagnostic]:
+        diagnostics = []
+        if meta.status == IssueStatus.CLOSED and not meta.solution:
+            line = self._get_field_line(content, "status")
+            diagnostics.append(self._create_diagnostic(
+                f"Data Integrity: Closed issue {meta.id} missing 'solution' field.",
+                DiagnosticSeverity.Error,
+                line=line
+            ))
+        return diagnostics
+        
+    def _validate_references(self, meta: IssueMetadata, content: str, all_ids: Set[str]) -> List[Diagnostic]:
+        diagnostics = []
+        if not all_ids:
+            return diagnostics
+            
+        if meta.parent and meta.parent not in all_ids:
+             line = self._get_field_line(content, "parent")
+             diagnostics.append(self._create_diagnostic(
+                f"Broken Reference: Parent '{meta.parent}' not found.",
+                DiagnosticSeverity.Error,
+                line=line
+             ))
+             
+        for dep in meta.dependencies:
+            if dep not in all_ids:
+                line = self._get_field_line(content, "dependencies")
+                diagnostics.append(self._create_diagnostic(
+                    f"Broken Reference: Dependency '{dep}' not found.",
+                    DiagnosticSeverity.Error,
+                    line=line
+                 ))
+        return diagnostics
+
+    def _validate_time_consistency(self, meta: IssueMetadata, content: str) -> List[Diagnostic]:
+        diagnostics = []
+        c = meta.created_at
+        o = meta.opened_at
+        u = meta.updated_at
+        cl = meta.closed_at
+        
+        created_line = self._get_field_line(content, "created_at")
+        opened_line = self._get_field_line(content, "opened_at")
+        updated_line = self._get_field_line(content, "updated_at")
+        closed_line = self._get_field_line(content, "closed_at")
+
+        if o and c > o:
+             diagnostics.append(self._create_diagnostic("Time Travel: created_at > opened_at", DiagnosticSeverity.Warning, line=created_line))
+        
+        if u and c > u:
+             diagnostics.append(self._create_diagnostic("Time Travel: created_at > updated_at", DiagnosticSeverity.Warning, line=created_line))
+             
+        if cl:
+            if c > cl:
+                 diagnostics.append(self._create_diagnostic("Time Travel: created_at > closed_at", DiagnosticSeverity.Error, line=created_line))
+            if o and o > cl:
+                 diagnostics.append(self._create_diagnostic("Time Travel: opened_at > closed_at", DiagnosticSeverity.Error, line=opened_line))
+
+        return diagnostics
+
+    def _validate_checkbox_logic(self, content: str) -> List[Diagnostic]:
+        diagnostics = []
+        lines = content.split('\n')
+        
+        for i, line in enumerate(lines):
+            stripped = line.lstrip()
+            
+            # Syntax Check: - [?]
+            if stripped.startswith("- ["):
+                match = re.match(r"- \[([ x\-/])\]", stripped)
+                if not match:
+                    # Check for Common errors
+                    if re.match(r"- \[.{2,}\]", stripped): # [xx] or [  ]
+                         diagnostics.append(self._create_diagnostic("Invalid Checkbox: Use single character [ ], [x], [-], [/]", DiagnosticSeverity.Error, i))
+                    elif re.match(r"- \[([^ x\-/])\]", stripped): # [v], [o]
+                         diagnostics.append(self._create_diagnostic("Invalid Checkbox Status: Use [ ], [x], [-], [/]", DiagnosticSeverity.Error, i))
+        
+        return diagnostics

monoco/features/pty/core.py

@@ -0,0 +1,185 @@
+
+import asyncio
+import os
+import pty
+import select
+import signal
+import struct
+import fcntl
+import termios
+import logging
+from typing import Dict, Optional, Tuple, Any
+
+logger = logging.getLogger("monoco.pty")
+
+class PTYSession:
+    """
+    Manages a single PTY session connected to a subprocess (shell).
+    """
+    def __init__(self, session_id: str, cmd: list[str], env: Optional[Dict[str, str]] = None, cwd: Optional[str] = None):
+        self.session_id = session_id
+        self.cmd = cmd
+        self.env = env or os.environ.copy()
+        self.cwd = cwd or os.getcwd()
+        
+        self.fd: Optional[int] = None
+        self.pid: Optional[int] = None
+        self.proc = None # subprocess.Popen object
+        self.running = False
+        self.loop = asyncio.get_running_loop()
+
+    def start(self, cols: int = 80, rows: int = 24):
+        """
+        Spawn a subprocess connected to a new PTY using subprocess.Popen.
+        This provides better safety in threaded/asyncio environments than pty.fork().
+        """
+        import subprocess
+
+        # 1. Open PTY pair
+        master_fd, slave_fd = pty.openpty()
+        
+        # 2. Set initial size
+        self._set_winsize(master_fd, rows, cols)
+
+        try:
+            # 3. Spawn process
+            # start_new_session=True executes setsid()
+            self.proc = subprocess.Popen(
+                self.cmd,
+                stdin=slave_fd,
+                stdout=slave_fd,
+                stderr=slave_fd,
+                cwd=self.cwd,
+                env=self.env,
+                start_new_session=True,
+                close_fds=True # Important to close other FDs in child
+            )
+            
+            self.pid = self.proc.pid
+            self.fd = master_fd
+            self.running = True
+            
+            # 4. Close slave fd in parent (child has it open now)
+            os.close(slave_fd)
+            
+            logger.info(f"Started session {self.session_id} (PID: {self.pid})")
+            
+        except Exception as e:
+            logger.error(f"Failed to spawn process: {e}")
+            # Ensure we clean up fds if spawn fails
+            try:
+                os.close(master_fd)
+            except: pass
+            try:
+                os.close(slave_fd)
+            except: pass
+            raise e
+
+
+    def resize(self, cols: int, rows: int):
+        """
+        Resize the PTY.
+        """
+        if self.fd and self.running:
+            self._set_winsize(self.fd, rows, cols)
+
+    def write(self, data: bytes):
+        """
+        Write input data (from websocket) to the PTY master fd.
+        """
+        if self.fd and self.running:
+            os.write(self.fd, data)
+
+    async def read(self) -> bytes:
+        """
+        Read output data from PTY master fd (to forward to websocket).
+        """
+        if not self.fd or not self.running:
+            return b""
+            
+        try:
+            # Run in executor to avoid blocking the event loop
+            # pty read is blocking
+            return await self.loop.run_in_executor(None, self._read_blocking)
+        except OSError:
+            return b""
+
+    def _read_blocking(self) -> bytes:
+        try:
+            return os.read(self.fd, 1024)
+        except OSError:
+            return b""
+
+    def terminate(self):
+        """
+        Terminate the process and close the PTY.
+        """
+        self.running = False
+        
+        # Use Popen object if available
+        if self.proc:
+            try:
+                self.proc.terminate()
+                try:
+                    self.proc.wait(timeout=1.0)
+                except:
+                    # Force kill if not terminated
+                    self.proc.kill()
+                    self.proc.wait()
+            except Exception as e:
+                logger.error(f"Error terminating process: {e}")
+            self.proc = None
+            self.pid = None
+        elif self.pid:
+            # Fallback for legacy or if Popen obj lost
+            try:
+                os.kill(self.pid, signal.SIGTERM)
+                os.waitpid(self.pid, 0) # Reap zombie
+            except OSError:
+                pass
+            self.pid = None
+            
+        if self.fd:
+            try:
+                os.close(self.fd)
+            except OSError:
+                pass
+            self.fd = None
+        logger.info(f"Terminated session {self.session_id}")
+
+    def _set_winsize(self, fd: int, row: int, col: int, xpix: int = 0, ypix: int = 0):
+        winsize = struct.pack("HHHH", row, col, xpix, ypix)
+        fcntl.ioctl(fd, termios.TIOCSWINSZ, winsize)
+
+
+class PTYManager:
+    """
+    Singleton to manage multiple PTY sessions.
+    """
+    def __init__(self):
+        self.sessions: Dict[str, PTYSession] = {}
+
+    def create_session(self, session_id: str, cwd: str, cmd: list[str] = ["/bin/zsh"], env: Dict = None) -> PTYSession:
+        if session_id in self.sessions:
+            # In a real app, we might want to attach to existing?
+            # For now, kill and recreate (or error)
+            self.close_session(session_id)
+            
+        session = PTYSession(session_id, cmd, env, cwd)
+        self.sessions[session_id] = session
+        return session
+
+    def get_session(self, session_id: str) -> Optional[PTYSession]:
+        return self.sessions.get(session_id)
+
+    def close_session(self, session_id: str):
+        if session_id in self.sessions:
+            self.sessions[session_id].terminate()
+            del self.sessions[session_id]
+
+    def close_all_sessions(self):
+        """
+        Terminate all active PTY sessions.
+        """
+        for session_id in list(self.sessions.keys()):
+            self.close_session(session_id)