@scemoon/cdh 1.0.4 → 1.0.6

package/onecode/storage/activity.py

@@ -1,15 +1,14 @@
 from __future__ import annotations
 
-import json
 import uuid
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
 
-from sqlalchemy import Column, String, Text, DateTime, JSON, create_engine
+from sqlalchemy import Column, String, DateTime, JSON, create_engine
 from sqlalchemy.orm import declarative_base, sessionmaker
 
-from onecode.config import CLOUD_DEV_HARNESS_DIR
+from onecode.config import ONECODE_DIR
 
 Base = declarative_base()
 
@@ -28,7 +27,7 @@ class ActivityRecord(Base):
 class ActivityRecorder:
     def __init__(self, db_path: Optional[Path] = None):
         if db_path is None:
-            db_path = CLOUD_DEV_HARNESS_DIR / "sessions" / "cdh.db"
+            db_path = ONECODE_DIR / "sessions" / "cdh.db"
         db_path.parent.mkdir(parents=True, exist_ok=True)
         self.engine = create_engine(f"sqlite:///{db_path}")
         Base.metadata.create_all(self.engine)

package/onecode/storage/session.py

@@ -9,14 +9,13 @@ from typing import Optional
 from sqlalchemy import (
     Column,
     String,
-    Text,
     DateTime,
     JSON,
     create_engine,
 )
-from sqlalchemy.orm import declarative_base, Session as SASession, sessionmaker
+from sqlalchemy.orm import declarative_base, sessionmaker
 
-from onecode.config import CLOUD_DEV_HARNESS_DIR
+from onecode.config import ONECODE_DIR
 
 Base = declarative_base()
 
@@ -43,7 +42,7 @@ class SessionRecord(Base):
 class SessionStore:
     def __init__(self, db_path: Optional[Path] = None):
         if db_path is None:
-            db_path = CLOUD_DEV_HARNESS_DIR / "sessions" / "cdh.db"
+            db_path = ONECODE_DIR / "sessions" / "cdh.db"
         db_path.parent.mkdir(parents=True, exist_ok=True)
         self.engine = create_engine(f"sqlite:///{db_path}")
         Base.metadata.create_all(self.engine)

package/onecode/tasks/manager.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import uuid
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Callable, Optional
@@ -16,8 +16,6 @@ from onecode.tasks.models import (
     TaskChecklistState,
     TaskGateRecord,
     TaskToolCallSummary,
-    TodoItem,
-    TodoStatus,
 )
 
 
@@ -56,6 +54,8 @@ class TaskManager:
         self._storage_path = storage_path or Path.home() / ".cdh" / "tasks"
         self._executor: Optional[TaskExecutor] = None
         self._worker_task: Optional[asyncio.Task] = None
+        self._semaphore = asyncio.Semaphore(5)
+        self._shutdown: bool = False
 
     def set_executor(self, executor: TaskExecutor) -> None:
         self._executor = executor
@@ -90,11 +90,14 @@ class TaskManager:
             self._worker_task = asyncio.create_task(self._worker_loop())
 
     async def _worker_loop(self) -> None:
-        while True:
+        while not self._shutdown:
             try:
-                task = await self._queue.get()
+                task = await asyncio.wait_for(self._queue.get(), timeout=30)
                 if task.id not in self._running:
-                    self._running[task.id] = asyncio.create_task(self._run_task(task))
+                    async with self._semaphore:
+                        self._running[task.id] = asyncio.create_task(self._run_task(task))
+            except asyncio.TimeoutError:
+                continue
             except asyncio.CancelledError:
                 break
             except Exception as e:
@@ -112,7 +115,10 @@ class TaskManager:
             if self._executor:
                 cancel = asyncio.Event()
                 events: asyncio.Queue = asyncio.Queue()
-                result = await self._executor.execute(execution, events, cancel)
+                result = await asyncio.wait_for(
+                    self._executor.execute(execution, events, cancel),
+                    timeout=300,
+                )
                 task_record.status = TaskStatus.COMPLETED if result.get("success") else TaskStatus.FAILED
                 task_record.error = result.get("error")
             else:
@@ -147,8 +153,7 @@ class TaskManager:
             return list(self._tasks.values())
         return [t for t in self._tasks.values() if t.status == status]
 
-    def add_todo_to_task(self, task_id: str, content: str, status: str = "pending") -> Optional["TaskChecklistItem"]:
-        from onecode.tasks.models import TaskChecklistItem
+    def add_todo_to_task(self, task_id: str, content: str, status: str = "pending") -> Optional["TaskChecklistItem"]:  # noqa: F821
         task = self._tasks.get(task_id)
         if not task:
             return None
@@ -211,9 +216,17 @@ class TaskManager:
         return True
 
     async def stop(self) -> None:
+        self._shutdown = True
         if self._worker_task:
             self._worker_task.cancel()
             try:
                 await self._worker_task
             except asyncio.CancelledError:
-                pass
+                pass
+        if self._running:
+            results = await asyncio.gather(
+                *self._running.values(), return_exceptions=True,
+            )
+            for tid, res in zip(list(self._running.keys()), results):
+                if isinstance(res, Exception):
+                    logger.warning("Task %s exited with error: %s", tid, res)

package/onecode/trace/tracer.py

@@ -5,10 +5,9 @@ import time
 import uuid
 from contextlib import contextmanager
 from datetime import datetime, timezone
-from pathlib import Path
 from typing import Any, Optional
 
-from onecode.config import CLOUD_DEV_HARNESS_DIR
+from onecode.config import ONECODE_DIR
 
 
 class Span:
@@ -55,7 +54,7 @@ class Tracer:
         self.recording: bool = False
         self.spans: list[Span] = []
         self.stack: list[str] = []
-        self.trace_dir = CLOUD_DEV_HARNESS_DIR / "traces"
+        self.trace_dir = ONECODE_DIR / "traces"
         self.trace_dir.mkdir(parents=True, exist_ok=True)
         self._otlp_endpoint: Optional[str] = None
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scemoon/cdh",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Cloud Dev Harness - cloud-native development Agent framework",
   "keywords": ["ai", "agent", "cloud", "development", "cli", "tui"],
   "license": "MIT",

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cloud-dev-harness"
-version = "1.0.0"
+version = "1.0.5"
 description = "Cloud Dev Harness - cloud-native development Agent framework with A2TUI"
 requires-python = ">=3.14.2"
 dependencies = [
@@ -57,6 +57,9 @@ onecode = [
     "builtin_skills/**/*",
 ]
 
+[tool.ruff]
+exclude = ["tui/", "dist/", ".venv/"]
+
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 
@@ -66,5 +69,6 @@ dev = [
     "pyinstrument>=5.1.1",
     "pytest>=9.0.3",
     "pytest-asyncio>=1.4.0",
+    "pytest-cov>=6.0.0",
     "textual-dev>=1.8.0",
 ]

package/run.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
-const { spawn, execSync } = require('child_process');
+const { spawn, spawnSync, execSync } = require('child_process');
 const path = require('path');
+const fs = require('fs');
+const os = require('os');
 const pkg = require('./package.json');
 
 function exec(cmd, opts = {}) {
@@ -11,6 +13,12 @@ function exec(cmd, opts = {}) {
   }
 }
 
+function execVerbose(cmd, label) {
+  if (label) console.log(`cdh: ${label}`);
+  const r = spawnSync(cmd, { shell: true, stdio: 'inherit' });
+  return { ok: r.status === 0 };
+}
+
 function checkPython() {
   const script = 'import sys; v=sys.version_info; print(f"{v.major}.{v.minor}")';
   const r = exec(`python3 -c "${script}"`);
@@ -32,11 +40,49 @@ function checkCdhInstalled(pythonCmd) {
   return exec(`${pythonCmd} -m pip show cloud-dev-harness 2>/dev/null`).ok;
 }
 
+function uninstallCmd() {
+  const cdhDir = path.join(os.homedir(), '.cdh');
+  const pythonDir = path.join(cdhDir, 'python');
+
+  console.log('cdh: Uninstalling Cloud Dev Harness...');
+  console.log('');
+
+  if (fs.existsSync(pythonDir)) {
+    console.log(`cdh: Removing Python environment at ${pythonDir}...`);
+    fs.rmSync(pythonDir, { recursive: true, force: true });
+  }
+
+  if (fs.existsSync(cdhDir)) {
+    console.log(`cdh: Removing global state at ${cdhDir}...`);
+    fs.rmSync(cdhDir, { recursive: true, force: true });
+  }
+
+  console.log('');
+  console.log('cdh: Cleanup complete. To finish uninstall:');
+  console.log('');
+  console.log('  1. Remove the npm package:');
+  console.log('     pnpm remove -g @scemoon/cdh');
+  console.log('     # or: npm uninstall -g @scemoon/cdh');
+  console.log('');
+  console.log('  2. Check your shell config (~/.zshrc, ~/.bashrc, etc.) for:');
+  console.log('     export PATH="$HOME/.cdh/python/bin:$PATH"');
+  console.log('     Remove this line if present.');
+  console.log('');
+
+  process.exit(0);
+}
+
 function run(pythonModule) {
   const PKG_DIR = __dirname;
-  const PYTHON_ENV_DIR = path.join(require('os').homedir(), '.cdh', 'python');
+  const PYTHON_ENV_DIR = path.join(os.homedir(), '.cdh', 'python');
 
   const args = process.argv.slice(2);
+
+  if (args[0] === 'uninstall') {
+    uninstallCmd();
+    return;
+  }
+
   if (args.includes('--version') || args.includes('-v')) {
     console.log(pkg.version);
     process.exit(0);
@@ -49,13 +95,19 @@ function run(pythonModule) {
     console.error(`cdh: Python ${py.version || 'not found'}, version 3.14+ is required.`);
 
     if (checkUv()) {
-      console.log('cdh: Creating Python environment with uv...');
-      exec(`uv venv "${PYTHON_ENV_DIR}"`);
+      if (fs.existsSync(PYTHON_ENV_DIR)) {
+        console.log('cdh: Python environment exists, reusing...');
+      } else {
+        const rv = execVerbose(`uv venv "${PYTHON_ENV_DIR}"`, 'Creating Python environment with uv...');
+        if (!rv.ok) {
+          console.error('cdh: Failed to create Python environment.');
+          process.exit(1);
+        }
+      }
       const venvPython = path.join(PYTHON_ENV_DIR, 'bin', 'python');
-      console.log('cdh: Installing cloud-dev-harness...');
-      const r = exec(`uv pip install "${PKG_DIR}" --python "${venvPython}"`);
-      if (!r.ok) {
-        console.error('cdh: Install failed:', r.out);
+      const ri = execVerbose(`uv pip install "${PKG_DIR}" --python "${venvPython}"`, 'Installing cloud-dev-harness...');
+      if (!ri.ok) {
+        console.error('cdh: Install failed.');
         process.exit(1);
       }
       if (isPostinstall) {
@@ -72,12 +124,14 @@ function run(pythonModule) {
   }
 
   if (!checkCdhInstalled(py.pythonCmd)) {
-    console.log('cdh: Installing cloud-dev-harness...');
-    const r = checkUv()
-      ? exec(`uv pip install "${PKG_DIR}" --python "${py.pythonCmd}"`)
-      : exec(`${py.pythonCmd} -m pip install "${PKG_DIR}"`);
-    if (!r.ok) {
-      console.error('cdh: Install failed:', r.out);
+    let ri;
+    if (checkUv()) {
+      ri = execVerbose(`uv pip install "${PKG_DIR}" --python "${py.pythonCmd}"`, 'Installing cloud-dev-harness...');
+    } else {
+      ri = execVerbose(`${py.pythonCmd} -m pip install "${PKG_DIR}"`, 'Installing cloud-dev-harness...');
+    }
+    if (!ri.ok) {
+      console.error('cdh: Install failed.');
       process.exit(1);
     }
   }

package/tui/acp/agent.py

@@ -28,7 +28,6 @@ from tui.acp import messages
 from tui.acp.prompt import build as build_prompt
 from tui import messages as tui_messages
 from tui.db import DB
-from tui import paths
 from tui import constants
 from tui.answer import Answer
 
@@ -88,6 +87,7 @@ class Agent(AgentBase):
         self._message_target: MessagePump | None = None
 
         self._terminal_count: int = 0
+        self.session_load_info: dict = {}
 
     @property
     def command(self) -> str | None:
@@ -122,9 +122,14 @@ class Agent(AgentBase):
             request: JSONRPC request object.
 
         """
-        assert self._process is not None, "Process should be present here"
+        if self._process is None:
+            logger.warning(
+                "Cannot send request %s: agent process is not running",
+                request.body,
+            )
+            return
 
-        logger.debug("[client] %s", request.body)
+        logger.info("[client] send: %s", request.body)
         if (stdin := self._process.stdin) is not None:
             stdin.write(b"%s\n" % request.body_json)
 
@@ -542,61 +547,64 @@ class Agent(AgentBase):
                 if (task := asyncio.current_task()) is not None:
                     tasks.discard(task)
 
-        while line := await process.stdout.readline():
-            # This line should contain JSON, which may be:
-            #   A) a JSONRPC request
-            #   B) a JSONRPC response to a previous request
-            if not line.strip():
-                continue
-
-            try:
-                line_str = line.decode("utf-8")
-            except Exception as error:
-                logger.error("Unable to decode utf-8 from agent: %s", error)
-                continue
-
-            logger.debug("[agent] %s", line_str.rstrip())
-            try:
-                agent_data: jsonrpc.JSONType = json.loads(line_str)
-            except Exception as error:
-                logger.error("Failed to decode JSON from agent: %s", error)
-                continue
-
-            if isinstance(agent_data, dict):
-                if "result" in agent_data or "error" in agent_data:
-                    # Wait for pending notification dispatch tasks so all ACP
-                    # messages are queued before the response future resolves.
-                    if tasks:
-                        await asyncio.gather(*tasks, return_exceptions=True)
-                        tasks.clear()
-                    API.process_response(agent_data)
+        try:
+            while line := await process.stdout.readline():
+                # This line should contain JSON, which may be:
+                #   A) a JSONRPC request
+                #   B) a JSONRPC response to a previous request
+                if not line.strip():
                     continue
 
-            elif isinstance(agent_data, list):
-                if not all(isinstance(datum, dict) for datum in agent_data):
-                    logger.error("Agent sent invalid data: %r", agent_data)
+                try:
+                    line_str = line.decode("utf-8")
+                except Exception as error:
+                    logger.error("Unable to decode utf-8 from agent: %s", error)
                     continue
 
-            if not isinstance(agent_data, dict):
-                logger.error("Invalid JSON from agent: %r", agent_data)
-                continue
+                logger.debug("[agent] %s", line_str.rstrip())
+                try:
+                    agent_data: jsonrpc.JSONType = json.loads(line_str)
+                except Exception as error:
+                    logger.error("Failed to decode JSON from agent: %s", error)
+                    continue
 
-            if not isinstance(agent_data, dict):
-                logger.error("Invalid JSON from agent: %r", agent_data)
-                continue
+                if isinstance(agent_data, dict):
+                    if "result" in agent_data or "error" in agent_data:
+                        # Wait for pending notification dispatch tasks so all ACP
+                        # messages are queued before the response future resolves.
+                        if tasks:
+                            await asyncio.gather(*tasks, return_exceptions=True)
+                            tasks.clear()
+                        API.process_response(agent_data)
+                        continue
+
+                elif isinstance(agent_data, list):
+                    if not all(isinstance(datum, dict) for datum in agent_data):
+                        logger.error("Agent sent invalid data: %r", agent_data)
+                        continue
+
+                if not isinstance(agent_data, dict):
+                    logger.error("Invalid JSON from agent: %r", agent_data)
+                    continue
 
-            # By this point we know it is a JSON RPC call
-            assert isinstance(agent_data, dict)
-            tasks.add(asyncio.create_task(call_jsonrpc(agent_data)))
-            await asyncio.sleep(0)
+                if not isinstance(agent_data, dict):
+                    logger.error("Invalid JSON from agent: %r", agent_data)
+                    continue
 
-        # Cancel all remaining tasks and wait for them to finish
-        for task in tasks:
-            task.cancel()
+                # By this point we know it is a JSON RPC call
+                assert isinstance(agent_data, dict)
+                tasks.add(asyncio.create_task(call_jsonrpc(agent_data)))
+                await asyncio.sleep(0)
+        except Exception as e:
+            logger.exception("Agent read loop failed: %s", e)
+        finally:
+            # Cancel all remaining tasks and wait for them to finish
+            for task in tasks:
+                task.cancel()
 
-        # Wait for all tasks to complete cancellation
-        if tasks:
-            await asyncio.gather(*tasks, return_exceptions=True)
+            # Wait for all tasks to complete cancellation
+            if tasks:
+                await asyncio.gather(*tasks, return_exceptions=True)
 
         if process.returncode:
             assert process.stderr is not None
@@ -691,6 +699,7 @@ class Agent(AgentBase):
             protocol=data["protocol"],
             meta=data["meta"],
         )
+        self.post_message(tui_messages.SessionUpdate(session_pk=self.session_pk))
         self._pending_session_data = None
         await self._save_last_session_to_cdh()
 
@@ -816,8 +825,19 @@ class Agent(AgentBase):
         self.post_message(messages.SessionReplay(active=True))
         try:
             response = await session_load_response.wait()
+            self.session_load_info = {
+                "total_messages": response.get("_total_messages", 0),
+                "visible_start": response.get("_visible_start", 0),
+            }
         finally:
-            self.post_message(messages.SessionReplay(active=False))
+            self.post_message(messages.SessionReplay(
+                active=False,
+                total_messages=self.session_load_info.get("total_messages", 0),
+                visible_count=self.session_load_info.get("total_messages", 0) - self.session_load_info.get("visible_start", 0),
+            ))
+
+        if error := response.get("error"):
+            logger.warning("Session load error: %s", error)
 
         if (modes := response.get("modes", None)) is not None:
             current_mode = modes["currentModeId"]
@@ -845,10 +865,20 @@ class Agent(AgentBase):
             await self._ensure_db_session()
 
         if session_title:
-            self.post_message(tui_messages.SessionUpdate(name=session_title))
+            self.post_message(tui_messages.SessionUpdate(name=session_title, session_pk=self.session_pk))
 
         await self._save_last_session_to_cdh()
 
+    async def acp_load_earlier_messages(self, offset: int, limit: int) -> None:
+        """Load a range of earlier messages from the current session."""
+        assert self.session_id is not None
+        with self.request():
+            response = api.session_load_earlier(self.session_id, offset, limit)
+        try:
+            await response.wait()
+        except jsonrpc.JSONRPCError:
+            pass
+
     async def acp_session_prompt(
         self, prompt: list[protocol.ContentBlock]
     ) -> str | None:
@@ -858,6 +888,14 @@ class Agent(AgentBase):
             The stop reason.
 
         """
+        if self._process is None:
+            self.post_message(
+                AgentFail(
+                    "Agent process is not running",
+                    "The agent subprocess has terminated. Restart the session to continue.",
+                )
+            )
+            return None
         with self.request():
             session_prompt = api.session_prompt(prompt, self.session_id)
         try:
@@ -908,6 +946,15 @@ class Agent(AgentBase):
     async def set_mode(self, mode_id: str) -> str | None:
         return await self.acp_session_set_mode(mode_id)
 
+    async def acp_session_clear_todos(self) -> dict:
+        """Clear all todos via the session/clear_todos RPC."""
+        if self.session_id is None:
+            return {"cleared": False}
+        with self.request():
+            response = api.session_clear_todos(self.session_id)
+        result = await response.wait()
+        return result or {"cleared": False}
+
     async def set_session_name(self, name: str) -> None:
         if self.session_pk is None:
             return
@@ -919,16 +966,36 @@ class Agent(AgentBase):
             if session.load():
                 session.name = name
                 session.save()
-        self.post_message(tui_messages.SessionUpdate(name=name))
+        self.post_message(tui_messages.SessionUpdate(name=name, session_pk=self.session_pk))
 
     async def acp_session_cancel(self) -> bool:
-        with self.request():
-            response = api.session_cancel(self.session_id, {})
+        """Send session/cancel notification to the agent subprocess.
+
+        Writes directly to stdin with drain() to ensure the message is
+        actually flushed through the pipe, unlike the Request path which
+        is synchronous and cannot drain.
+        """
+        if not self.session_id:
+            logger.info("[client] session/cancel: no session_id, skipping")
+            return False
+        cancel_msg = {
+            "jsonrpc": "2.0",
+            "method": "session/cancel",
+            "params": {"sessionId": self.session_id, "_meta": {}},
+        }
+        data = json.dumps(cancel_msg).encode("utf-8") + b"\n"
+        logger.info("[client] session/cancel: sending %s", cancel_msg)
+        stdin = self._process.stdin if self._process else None
+        if stdin is None:
+            logger.info("[client] session/cancel: no stdin pipe, skipping")
+            return False
+        stdin.write(data)
         try:
-            await response.wait()
-        except jsonrpc.APIError:
-            # No-op if there is nothing to cancel
+            await stdin.drain()
+        except OSError:
+            logger.info("[client] session/cancel: drain failed", exc_info=True)
             return False
+        logger.info("[client] session/cancel: sent successfully")
         return True
 
     async def cancel(self) -> bool:

package/tui/acp/api.py

@@ -59,3 +59,15 @@ def session_set_mode(sessionId: str, modeId: str) -> protocol.SetSessionModeResp
 def session_save(sessionId: str) -> dict:
     """Save the session state."""
     ...
+
+
+@API.method(name="session/clear_todos")
+def session_clear_todos(sessionId: str) -> dict:
+    """Clear all todos in the current session."""
+    ...
+
+
+@API.method(name="session/load_earlier")
+def session_load_earlier(sessionId: str, offset: int, limit: int) -> dict:
+    """Load a range of earlier messages from the current session."""
+    ...

package/tui/acp/messages.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 
 from asyncio import Future
-from typing import Any, Mapping, TYPE_CHECKING
+from typing import Mapping, TYPE_CHECKING
 from textual.message import Message
 
 import rich.repr
@@ -38,6 +38,8 @@ class Thinking(AgentMessage):
 class SessionReplay(AgentMessage):
     """Marks the start/end of a session replay (loading historical messages)."""
     active: bool
+    total_messages: int = 0
+    visible_count: int = 0
 
 
 @dataclass