@scemoon/cdh 1.0.9 → 1.0.10-beta.1

package/onecode/server/app.py

@@ -1,251 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-from typing import Optional
-
-from starlette.applications import Starlette
-from starlette.responses import JSONResponse, Response
-from starlette.routing import Route
-
-from onecode.agent.engine import AgentEngine
-
-logger = logging.getLogger("onecode.server")
-
-
-async def _sse_publisher(engine: AgentEngine, response: Response):
-    """Stream agent output as SSE events."""
-    send = response.__dict__.get("send")
-
-    async def _on_text(text: str):
-        if send:
-            try:
-                await send({
-                    "type": "http.response.body",
-                    "body": f"data: {json.dumps({'type': 'text', 'content': text})}\n\n".encode(),
-                    "more_body": True,
-                })
-            except Exception:
-                pass
-
-    engine.on_text_chunk = _on_text
-    return send
-
-
-class AgentServer:
-    """HTTP/SSE server for remote agent access (Clawd-Code pattern)."""
-
-    def __init__(self, engine: AgentEngine, host: str = "127.0.0.1", port: int = 8765):
-        self._engine = engine
-        self._host = host
-        self._port = port
-        self._app = self._build_app()
-        self._server: Optional[asyncio.AbstractServer] = None
-
-    def _build_app(self) -> Starlette:
-        routes = [
-            Route("/health", endpoint=self._handle_health, methods=["GET"]),
-            Route("/status", endpoint=self._handle_status, methods=["GET"]),
-            Route("/chat", endpoint=self._handle_chat, methods=["POST"]),
-            Route("/events", endpoint=self._handle_events, methods=["GET"]),
-        ]
-        return Starlette(routes=routes, on_shutdown=[self._shutdown])
-
-    async def _handle_health(self, request):
-        return JSONResponse({"status": "ok"})
-
-    async def _handle_status(self, request):
-        return JSONResponse({
-            "iterations": self._engine.iterations,
-            "total_tokens": self._engine.total_tokens,
-            "provider": getattr(self._engine.app, "current_provider", None),
-            "model": getattr(self._engine.app, "current_model", None),
-        })
-
-    async def _handle_chat(self, request):
-        try:
-            body = await request.json()
-        except Exception:
-            return JSONResponse({"error": "invalid JSON body"}, status_code=400)
-
-        user_input = body.get("message", "")
-        if not user_input:
-            return JSONResponse({"error": "message is required"}, status_code=400)
-
-        response_text = await self._engine.chat(user_input)
-        return JSONResponse({"response": response_text})
-
-    async def _handle_events(self, request):
-        async def _send_events(send):
-            await send({
-                "type": "http.response.start",
-                "status": 200,
-                "headers": [
-                    (b"content-type", b"text/event-stream"),
-                    (b"cache-control", b"no-cache"),
-                    (b"connection", b"keep-alive"),
-                    (b"access-control-allow-origin", b"*"),
-                ],
-            })
-
-            user_input = request.query_params.get("message", "")
-            if not user_input:
-                await send({
-                    "type": "http.response.body",
-                    "body": b"data: {\"error\": \"message query param required\"}\n\n",
-                    "more_body": False,
-                })
-                return
-
-            from onecode.models.messages import StreamEvent, StreamEventType
-
-            _tc_args: dict[str, str] = {}
-
-            # SSE heartbeat — periodic comment lines to keep connection alive
-            # during long thinking/processing periods.
-            _heartbeat_interval = 15
-
-            async def _heartbeat():
-                while True:
-                    try:
-                        await asyncio.sleep(_heartbeat_interval)
-                        await send({
-                            "type": "http.response.body",
-                            "body": b": keepalive\n\n",
-                            "more_body": True,
-                        })
-                    except asyncio.CancelledError:
-                        return
-                    except Exception:
-                        return
-
-            _hb_task = asyncio.create_task(_heartbeat())
-
-            def _on_tool_call_delta(call_id: str, name: str, args_delta: str) -> None:
-                if not args_delta:
-                    return
-                _tc_args[call_id] = _tc_args.get(call_id, "") + args_delta
-                payload = json.dumps({
-                    "type": "tool_call_args",
-                    "toolCallId": call_id,
-                    "name": name,
-                    "args": _tc_args[call_id],
-                })
-                asyncio.ensure_future(send({
-                    "type": "http.response.body",
-                    "body": f"data: {payload}\n\n".encode(),
-                    "more_body": True,
-                }))
-
-            self._engine.on_tool_call_delta = _on_tool_call_delta
-
-            text_buffer = []
-            try:
-                async for event in self._engine.chat_stream(user_input):
-                    if isinstance(event, StreamEvent):
-                        if event.type == StreamEventType.TEXT_DELTA and event.text:
-                            text_buffer.append(event.text)
-                            payload = json.dumps({"type": "delta", "text": event.text})
-                            await send({
-                                "type": "http.response.body",
-                                "body": f"data: {payload}\n\n".encode(),
-                                "more_body": True,
-                            })
-                        elif event.type == StreamEventType.THINKING and event.thinking:
-                            payload = json.dumps({"type": "thinking", "content": event.thinking})
-                            await send({
-                                "type": "http.response.body",
-                                "body": f"data: {payload}\n\n".encode(),
-                                "more_body": True,
-                            })
-                        elif event.type == StreamEventType.TOOL_CALL_START:
-                            payload = json.dumps({
-                                "type": "tool_call_start",
-                                "toolCallId": event.tool_id,
-                                "name": event.tool_name,
-                            })
-                            await send({
-                                "type": "http.response.body",
-                                "body": f"data: {payload}\n\n".encode(),
-                                "more_body": True,
-                            })
-                        elif event.type == StreamEventType.TOOL_CALL_COMPLETE:
-                            payload = json.dumps({
-                                "type": "tool_call_complete",
-                                "toolCallId": event.tool_id,
-                                "name": event.tool_name,
-                                "args": event.tool_args,
-                            })
-                            await send({
-                                "type": "http.response.body",
-                                "body": f"data: {payload}\n\n".encode(),
-                                "more_body": True,
-                            })
-                        elif event.type == StreamEventType.TOOL_RESULT:
-                            payload = json.dumps({
-                                "type": "tool_result",
-                                "toolCallId": event.tool_id,
-                                "content": event.result_content,
-                                "isError": event.result_is_error,
-                            })
-                            await send({
-                                "type": "http.response.body",
-                                "body": f"data: {payload}\n\n".encode(),
-                                "more_body": True,
-                            })
-                        elif event.type == StreamEventType.ERROR:
-                            payload = json.dumps({"type": "error", "message": event.error_message})
-                            await send({
-                                "type": "http.response.body",
-                                "body": f"data: {payload}\n\n".encode(),
-                                "more_body": True,
-                            })
-                    else:
-                        text_buffer.append(str(event))
-            finally:
-                _hb_task.cancel()
-                try:
-                    await _hb_task
-                except (asyncio.CancelledError, Exception):
-                    pass
-
-            full_text = "".join(text_buffer)
-            payload = json.dumps({"type": "done", "text": full_text})
-            await send({
-                "type": "http.response.body",
-                "body": f"data: {payload}\n\n".encode(),
-                "more_body": False,
-            })
-
-        return Response(
-            content=None,
-            media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
-                "Access-Control-Allow-Origin": "*",
-            },
-        )
-
-    async def _shutdown(self):
-        logger.info("Server shutting down")
-
-    async def start(self):
-        import uvicorn
-        cfg = uvicorn.Config(
-            self._app,
-            host=self._host,
-            port=self._port,
-            log_level="info",
-            lifespan="on",
-        )
-        server = uvicorn.Server(cfg)
-        logger.info(f"Agent server starting on http://{self._host}:{self._port}")
-        await server.serve()
-
-    def start_background(self) -> None:
-        """Start server in background thread."""
-        import threading
-        t = threading.Thread(target=lambda: asyncio.run(self.start()), daemon=True)
-        t.start()

package/onecode/skills/__init__.py

@@ -1,11 +0,0 @@
-from onecode.skills.model import Skill
-from onecode.skills.loader import SkillLoader
-from onecode.skills.frontmatter import parse_frontmatter
-from onecode.skills.argument_substitution import substitute_arguments
-from onecode.skills.create import create_skill_scaffold
-
-__all__ = [
-    "Skill", "SkillLoader",
-    "parse_frontmatter", "substitute_arguments",
-    "create_skill_scaffold",
-]

package/onecode/skills/argument_substitution.py

@@ -1,38 +0,0 @@
-from __future__ import annotations
-
-import re
-
-
-_PATH_RE = re.compile(r'\$path')
-_ARG_RE = re.compile(r'\$(\d+)')
-_ARGS_RE = re.compile(r'\$ARGUMENTS')
-
-
-def substitute_arguments(content: str, arguments: list[str] | None = None) -> str:
-    """Substitute positional arguments in skill content.
-
-    Supports:
-      $path        -> first argument
-      $0, $1, $2   -> positional arguments
-      $ARGUMENTS   -> all arguments joined by space
-    """
-    args = arguments or []
-    text = content
-
-    # $path -> first argument
-    if args:
-        text = _PATH_RE.sub(args[0], text)
-    else:
-        text = _PATH_RE.sub("", text)
-
-    # $0, $1, $2...
-    def _replace_arg(m: re.Match) -> str:
-        idx = int(m.group(1))
-        return args[idx] if idx < len(args) else ""
-
-    text = _ARG_RE.sub(_replace_arg, text)
-
-    # $ARGUMENTS -> all joined
-    text = _ARGS_RE.sub(" ".join(args), text)
-
-    return text

package/onecode/skills/bootstrap.py

@@ -1,37 +0,0 @@
-"""onecode bootstrap — installs default built-in skills.
-
-Called at onecode startup (or cdh launch) to install built-in skills
-(git, shell) into ~/.onecode/skills/ on first run.
-"""
-
-from __future__ import annotations
-
-import logging
-import shutil
-from pathlib import Path
-
-logger = logging.getLogger("onecode.skills.bootstrap")
-
-
-def ensure_onecode_default_skills() -> None:
-    """Install built-in skills (git, shell) to ~/.onecode/skills/ on first run."""
-    from onecode.config import ONECODE_DIR
-
-    target_dir = ONECODE_DIR / "skills"
-    target_dir.mkdir(parents=True, exist_ok=True)
-
-    builtin_root = Path(__file__).resolve().parent.parent / "builtin_skills"
-    if not builtin_root.exists():
-        return
-
-    for d in sorted(builtin_root.iterdir()):
-        if not d.is_dir():
-            continue
-        if not (d / "skill.yaml").exists():
-            continue
-        name = d.name
-        target = target_dir / name
-        if target.exists():
-            continue
-        shutil.copytree(d, target)
-        logger.info("default skill %s installed \u2192 %s/%s", name, target_dir, name)

package/onecode/skills/create.py

@@ -1,56 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Optional
-
-import yaml
-
-
-SKILL_TEMPLATE = """---
-name: {name}
-description: {description}
-enabled: true
----
-
-# {name} Skill
-
-## Description
-{description}
-
-## Usage
-When the user asks about {name}, follow these instructions:
-
-## Guidelines
-- Follow the project conventions
-- Use appropriate tools
-"""
-
-
-def create_skill_scaffold(
-    skills_dir: Path,
-    name: str,
-    description: str = "",
-) -> Optional[str]:
-    """Create a new skill directory with SKILL.md and skill.yaml.
-
-    Returns error message or None on success.
-    """
-    skill_path = skills_dir / name
-    if skill_path.exists():
-        return f"Skill '{name}' already exists at {skill_path}"
-
-    skill_path.mkdir(parents=True, exist_ok=True)
-
-    skill_md = skill_path / "SKILL.md"
-    skill_md.write_text(
-        SKILL_TEMPLATE.format(name=name, description=description or f"A skill for {name}"),
-        encoding="utf-8",
-    )
-
-    skill_yaml = skill_path / "skill.yaml"
-    skill_yaml.write_text(
-        yaml.dump({"name": name, "description": description, "enabled": True}, default_flow_style=False),
-        encoding="utf-8",
-    )
-
-    return None

package/onecode/skills/frontmatter.py

@@ -1,33 +0,0 @@
-from __future__ import annotations
-
-import re
-from typing import Any
-
-import yaml
-
-
-_FRONTMATTER_RE = re.compile(
-    r'^---\s*\n(.*?)\n---\s*\n?',
-    re.DOTALL,
-)
-
-
-def parse_frontmatter(text: str) -> tuple[dict[str, Any], str]:
-    """Parse YAML frontmatter from markdown text.
-
-    Returns (frontmatter_dict, body_text). If no frontmatter,
-    frontmatter_dict is empty and body_text is the full text.
-    """
-    match = _FRONTMATTER_RE.match(text)
-    if not match:
-        return {}, text
-
-    yaml_block = match.group(1)
-    body = text[match.end():]
-
-    try:
-        frontmatter = yaml.safe_load(yaml_block) or {}
-    except yaml.YAMLError:
-        frontmatter = {}
-
-    return frontmatter, body

package/onecode/skills/loader.py

@@ -1,215 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Optional
-
-import yaml
-
-from onecode.skills.frontmatter import parse_frontmatter
-from onecode.skills.model import Skill
-
-from onecode.config import ONECODE_DIR
-
-
-USER_SKILLS_DIR = ONECODE_DIR / "skills"
-BUILTIN_SKILLS_DIR = Path(__file__).resolve().parent.parent / "builtin_skills"
-
-ENGINE_SKILL_PATHS = {
-    "opencode": Path.home() / ".opencode" / "skills",
-    "claude": Path.home() / ".claude" / "skills",
-    "onecode": Path.home() / ".onecode" / "skills",
-}
-
-
-class SkillLoader:
-    def __init__(self, workspace_root: Path | None = None):
-        self._workspace_root = workspace_root or Path.cwd()
-        self._cache: dict[str, Skill] | None = None
-
-    def _get_search_dirs(self) -> list[tuple[str, Path]]:
-        dirs = []
-
-        if USER_SKILLS_DIR.exists():
-            dirs.append(("onecode", USER_SKILLS_DIR))
-
-        for engine, path in ENGINE_SKILL_PATHS.items():
-            if path.exists():
-                dirs.append((engine, path))
-
-        agents_skills = self._workspace_root / ".agents" / "skills"
-        if agents_skills.exists():
-            dirs.append(("agents", agents_skills))
-
-        if BUILTIN_SKILLS_DIR.exists():
-            dirs.append(("builtin", BUILTIN_SKILLS_DIR))
-
-        return dirs
-
-    def _discover(self) -> dict[str, Skill]:
-        if self._cache is not None:
-            return self._cache
-
-        skills: dict[str, Skill] = {}
-        seen_names: set[str] = set()
-
-        for source, skills_dir in self._get_search_dirs():
-            if not skills_dir.exists():
-                continue
-            try:
-                for d in sorted(skills_dir.iterdir()):
-                    if not d.is_dir():
-                        continue
-                    skill_md = d / "SKILL.md"
-                    if not skill_md.exists():
-                        continue
-
-                    content = skill_md.read_text(encoding="utf-8")
-                    cfg = {}
-                    skill_yaml = d / "skill.yaml"
-                    if skill_yaml.exists():
-                        try:
-                            cfg = yaml.safe_load(skill_yaml.read_text(encoding="utf-8")) or {}
-                        except Exception:
-                            cfg = {}
-
-                    frontmatter, body = parse_frontmatter(content)
-
-                    raw_name = frontmatter.get("name") or cfg.get("name") or d.name
-                    name = raw_name.lower()
-
-                    valid, err = Skill.validate_name(name)
-                    if not valid:
-                        continue
-
-                    desc = frontmatter.get("description") or cfg.get("description", "")
-
-                    skill = Skill(
-                        name=name,
-                        description=desc,
-                        path=d,
-                        enabled=frontmatter.get("enabled", cfg.get("enabled", True)),
-                        allowed_tools=frontmatter.get("allowed_tools") or cfg.get("allowed_tools", []),
-                        arguments=frontmatter.get("arguments") or cfg.get("arguments", []),
-                        triggers=frontmatter.get("triggers") or cfg.get("triggers", []),
-                        phases=frontmatter.get("phases") or cfg.get("phases", []),
-                        content=body if body else content,
-                        license=frontmatter.get("license") or cfg.get("license", ""),
-                        compatibility=frontmatter.get("compatibility") or cfg.get("compatibility", ""),
-                        metadata=frontmatter.get("metadata") or cfg.get("metadata", {}),
-                    )
-
-                    if name not in seen_names:
-                        skills[name] = skill
-                        seen_names.add(name)
-
-            except Exception:
-                continue
-
-        self._cache = skills
-        return skills
-
-    def get_all(self) -> dict[str, Skill]:
-        return self._discover()
-
-    def get(self, name: str) -> Optional[Skill]:
-        return self._discover().get(name.lower())
-
-    def get_enabled(self) -> list[Skill]:
-        return [s for s in self._discover().values() if s.enabled]
-
-    def get_by_source(self, source_prefix: str) -> list[Skill]:
-        return [
-            s for s in self._discover().values()
-            if s.path and str(s.path).startswith(source_prefix)
-        ]
-
-    def search(self, keyword: str) -> list[Skill]:
-        kw = keyword.lower()
-        results: list[tuple[Skill, int]] = []
-
-        for skill in self._discover().values():
-            score = 0
-            name_lower = skill.name.lower()
-            desc_lower = skill.description.lower()
-
-            if kw == name_lower:
-                score += 100
-            elif kw in name_lower:
-                score += 50
-            if kw in desc_lower:
-                score += 30
-                if desc_lower.startswith(kw):
-                    score += 10
-            for trigger in skill.triggers:
-                if kw in trigger.lower():
-                    score += 20
-                    break
-            for phase in skill.phases:
-                if kw in phase.lower():
-                    score += 10
-                    break
-
-            if score > 0:
-                results.append((skill, score))
-
-        results.sort(key=lambda x: x[1], reverse=True)
-        return [s for s, _ in results]
-
-    def invalidate_cache(self) -> None:
-        self._cache = None
-
-    # Synonym expansion for trigger matching
-    TRIGGER_SYNONYMS = {
-        "understand": ["intent", "requirement", "spec", "需求", "需求分析"],
-        "plan": ["design", "architecture", "task", "dag", "规划", "设计"],
-        "verify": ["test", "tdd", "bdd", "quality", "验证", "测试"],
-        "deliver": ["deploy", "release", "production", "交付", "部署"],
-        "lifecycle": ["process", "workflow", "phase", "流程", "生命周期"],
-        "contract": ["api", "openapi", "asyncapi", "接口", "合约"],
-        "cross-stack": ["integration", "e2e", "end-to-end", "跨栈", "集成"],
-    }
-
-    def match_intent(self, user_input: str) -> list[Skill]:
-        """Match user input against skills using trigger synonyms and fuzzy matching.
-
-        Returns skills ordered by relevance score.
-        """
-        words = set(user_input.lower().split())
-        results: list[tuple[Skill, int]] = []
-
-        for skill in self._discover().values():
-            score = 0
-
-            # Direct trigger match
-            for trigger in skill.triggers:
-                trigger_lower = trigger.lower()
-                if trigger_lower in user_input.lower():
-                    score += 50
-                    if trigger_lower == user_input.lower().strip():
-                        score += 30
-
-            # Synonym expansion
-            expanded = set(words)
-            for phase, synonyms in self.TRIGGER_SYNONYMS.items():
-                if phase in [p.lower() for p in skill.phases]:
-                    for syn in synonyms:
-                        if syn in words:
-                            expanded.add(phase)
-                            score += 15
-
-            # Component prefix detection (NATIVE-FR, WEB-FR, INT-FR, etc.)
-            import re
-            fr_pattern = r'\b(NATIVE|DESKTOP|WEB|BE|WXA|MYA|TTA|INT)-FR-\d+'
-            if re.search(fr_pattern, user_input, re.IGNORECASE):
-                score += 40
-
-            # Phase keyword in user input
-            for phase in skill.phases:
-                if phase.lower() in user_input.lower():
-                    score += 25
-
-            if score > 0:
-                results.append((skill, score))
-
-        results.sort(key=lambda x: x[1], reverse=True)
-        return [s for s, _ in results]