@scemoon/cdh 1.0.8 → 1.0.9-beta.2

package/onecode/server/app.py

@@ -0,0 +1,251 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,37 @@
+"""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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,215 @@
+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]