@scemoon/cdh 1.0.0

package/onecode/codebase/tools.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Callable, Optional
+
+from onecode.agent.tools.registry import ToolResult, ToolSpec
+
+if TYPE_CHECKING:
+    from onecode.codebase import CodebaseEngine
+
+
+class CodebaseSearchTool:
+    def __init__(self, engine_factory: Callable[[], Optional[CodebaseEngine]]):
+        self._engine_factory = engine_factory
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="codebase_search",
+            description="Search the indexed codebase for code relevant to a query. "
+                        "Returns code chunks with file paths and line numbers. "
+                        "Use this to find relevant code before making changes.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search query describing what you're looking for",
+                    },
+                    "top_k": {
+                        "type": "integer",
+                        "description": "Number of results to return (1-20)",
+                        "default": 5,
+                    },
+                },
+                "required": ["query"],
+            },
+            is_read_only=True,
+        )
+
+    async def run(self, tool_input: dict) -> ToolResult:
+        query = tool_input.get("query", "")
+        top_k = min(max(int(tool_input.get("top_k", 5)), 1), 20)
+        if not query:
+            return ToolResult(content="Please provide a search query.")
+        try:
+            engine = self._engine_factory()
+            if engine is None:
+                return ToolResult(content="Codebase engine not available. Is it enabled in config?")
+            chunks = await engine.retrieve(query, top_k=top_k)
+            if not chunks:
+                return ToolResult(content="No results found. Try a different query.")
+            parts: list[str] = []
+            for i, c in enumerate(chunks, 1):
+                parts.append(
+                    f"[{i}] {c.file_path}:{c.start_line}-{c.end_line}\n"
+                    f"```\n{c.content}\n```"
+                )
+            return ToolResult(content="\n\n".join(parts))
+        except Exception as e:
+            return ToolResult(content=f"Search failed: {e}", is_error=True)

package/onecode/commands.py

@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from tui import platform_commands
+
+if TYPE_CHECKING:
+    from tui.widgets.conversation import Conversation
+
+
+async def _mode(conversation: Conversation, parameters: str) -> None:
+    from onecode.config import load_config, save_config
+
+    mode = parameters.strip().lower()
+    if mode not in ("build", "plan", "solo"):
+        conversation.notify("Mode must be: build, plan, or solo", title="/mode", severity="error")
+        return
+    cfg = load_config()
+    cfg.default_mode = mode
+    save_config(cfg)
+    conversation.app.settings.set("mode", mode)
+    await conversation.set_mode(mode)
+    conversation.flash(f"onecode mode set to [b]{mode}")
+
+
+async def _provider(conversation: Conversation, parameters: str) -> None:
+    from onecode.config import load_config, save_config
+
+    provider = parameters.strip()
+    if not provider:
+        conversation.notify("Provider name required", title="/provider", severity="error")
+        return
+    cfg = load_config()
+    cfg.default_provider = provider
+    save_config(cfg)
+    conversation.app.settings.set("provider", provider)
+    conversation.flash(f"onecode provider set to [b]{provider}")
+
+
+async def _model(conversation: Conversation, parameters: str) -> None:
+    from onecode.config import load_config, save_config
+
+    model = parameters.strip()
+    if not model:
+        conversation.notify("Model name required", title="/model", severity="error")
+        return
+    cfg = load_config()
+    cfg.default_model = model
+    save_config(cfg)
+    conversation.app.settings.set("model", model)
+    conversation.flash(f"onecode model set to [b]{model}")
+
+
+async def _skill(conversation: Conversation, parameters: str) -> None:
+    from tui.widgets.markdown_note import MarkdownNote
+    from onecode.skills.manager import SkillManager
+    from onecode.skills.loader import SkillLoader
+    from onecode.skills.create import create_skill_scaffold
+
+    parts = parameters.strip().split()
+    subcmd = parts[0].lower() if parts else ""
+    rest = " ".join(parts[1:]) if len(parts) > 1 else ""
+
+    if subcmd == "list":
+        loader = SkillLoader()
+        all_skills = loader.get_all()
+        if not all_skills:
+            await conversation.post(MarkdownNote("**No skills found.**\n\nUse `/skill add <name>` to create a new skill."))
+            return
+
+        lines = ["**Available Skills**\n"]
+        for name, skill in sorted(all_skills.items()):
+            enabled = skill.enabled
+            status = "✓" if enabled else "✗"
+            lines.append(f"- {status} **{name}**: {skill.description}")
+            if skill.path:
+                lines.append(f"  - Path: `{skill.path}`")
+        await conversation.post(MarkdownNote("\n".join(lines)))
+
+    elif subcmd == "add":
+        name = rest.strip()
+        if not name:
+            conversation.notify("Skill name required", title="/skill add", severity="error")
+            return
+
+        mgr = SkillManager()
+        if mgr.get(name):
+            conversation.notify(f"Skill '{name}' already exists", title="/skill add", severity="error")
+            return
+
+        err = create_skill_scaffold(mgr.skills_dir, name, f"A skill for {name}")
+        if err:
+            conversation.notify(f"Error: {err}", title="/skill add", severity="error")
+            return
+
+        await conversation.post(MarkdownNote(
+            f"**Skill '{name}' created**\n\n"
+            f"Location: `{mgr.skills_dir / name}`\n\n"
+            f"Edit the SKILL.md file to add instructions, then use `/skill list` to see it."
+        ))
+
+    elif subcmd == "remove":
+        name = rest.strip()
+        if not name:
+            conversation.notify("Skill name required", title="/skill remove", severity="error")
+            return
+
+        mgr = SkillManager()
+        err = mgr.remove(name)
+        if err:
+            conversation.notify(f"Error: {err}", title="/skill remove", severity="error")
+            return
+
+        await conversation.post(MarkdownNote(f"**Skill '{name}' removed.**"))
+
+    elif subcmd == "enable":
+        name = rest.strip()
+        if not name:
+            conversation.notify("Skill name required", title="/skill enable", severity="error")
+            return
+
+        mgr = SkillManager()
+        skill_data = mgr.get(name)
+        if not skill_data:
+            conversation.notify(f"Skill '{name}' not found", title="/skill enable", severity="error")
+            return
+
+        mgr.enable(name, True)
+        await conversation.post(MarkdownNote(f"**Skill '{name}' enabled.**"))
+
+    elif subcmd == "disable":
+        name = rest.strip()
+        if not name:
+            conversation.notify("Skill name required", title="/skill disable", severity="error")
+            return
+
+        mgr = SkillManager()
+        skill_data = mgr.get(name)
+        if not skill_data:
+            conversation.notify(f"Skill '{name}' not found", title="/skill disable", severity="error")
+            return
+
+        mgr.enable(name, False)
+        await conversation.post(MarkdownNote(f"**Skill '{name}' disabled.**"))
+
+    else:
+        await conversation.post(MarkdownNote(
+            "**Skill Management**\n\n"
+            "Usage:\n"
+            "- `/skill list` - List all skills\n"
+            "- `/skill add <name>` - Create a new skill\n"
+            "- `/skill remove <name>` - Remove a skill\n"
+            "- `/skill enable <name>` - Enable a skill\n"
+            "- `/skill disable <name>` - Disable a skill"
+        ))
+
+
+async def _mcp(conversation: Conversation, parameters: str) -> None:
+    from tui.widgets.markdown_note import MarkdownNote
+    from onecode.mcp.manager import MCPManager
+
+    parts = parameters.strip().split()
+    subcmd = parts[0].lower() if parts else ""
+    rest = " ".join(parts[1:]) if len(parts) > 1 else ""
+
+    if subcmd == "list":
+        mgr = MCPManager()
+        servers = mgr.list()
+        if not servers:
+            await conversation.post(MarkdownNote(
+                "**No MCP Servers**\n\n"
+                "Use `/mcp add <name> <url>` to add an MCP server."
+            ))
+            return
+
+        lines = ["**Configured MCP Servers**\n"]
+        for s in servers:
+            name = s.get("name", "unknown")
+            transport = s.get("transport", "sse")
+            enabled = s.get("enabled", True)
+            status = "✓" if enabled else "✗"
+            if transport == "sse":
+                url = s.get("url", "")
+                lines.append(f"- {status} **{name}** (SSE)")
+                if url:
+                    lines.append(f"  - URL: `{url}`")
+            else:
+                cmd = s.get("command", "")
+                args = " ".join(s.get("args", []))
+                lines.append(f"- {status} **{name}** (stdio)")
+                if cmd:
+                    lines.append(f"  - Command: `{cmd} {args}`")
+        await conversation.post(MarkdownNote("\n".join(lines)))
+
+    elif subcmd == "add":
+        args_parts = rest.split()
+        if len(args_parts) < 2:
+            conversation.notify("Usage: /mcp add <name> <url> [--type stdio]", title="/mcp add", severity="error")
+            return
+
+        name = args_parts[0]
+        url = args_parts[1]
+        transport = "sse"
+
+        mgr = MCPManager()
+        if mgr.get(name):
+            conversation.notify(f"MCP server '{name}' already exists", title="/mcp add", severity="error")
+            return
+
+        mgr.add(name, url, transport="sse")
+        await conversation.post(MarkdownNote(
+            f"**MCP Server '{name}' added**\n\n"
+            f"URL: `{url}`\n"
+            f"Transport: SSE\n\n"
+            f"Use `/mcp list` to see all servers."
+        ))
+
+    elif subcmd == "remove":
+        name = rest.strip()
+        if not name:
+            conversation.notify("Server name required", title="/mcp remove", severity="error")
+            return
+
+        mgr = MCPManager()
+        if not mgr.get(name):
+            conversation.notify(f"MCP server '{name}' not found", title="/mcp remove", severity="error")
+            return
+
+        mgr.remove(name)
+        await conversation.post(MarkdownNote(f"**MCP Server '{name}' removed.**"))
+
+    elif subcmd == "enable":
+        name = rest.strip()
+        if not name:
+            conversation.notify("Server name required", title="/mcp enable", severity="error")
+            return
+
+        mgr = MCPManager()
+        err = mgr.enable(name, True)
+        if err:
+            conversation.notify(f"Error: {err}", title="/mcp enable", severity="error")
+            return
+
+        await conversation.post(MarkdownNote(f"**MCP Server '{name}' enabled.**"))
+
+    elif subcmd == "disable":
+        name = rest.strip()
+        if not name:
+            conversation.notify("Server name required", title="/mcp disable", severity="error")
+            return
+
+        mgr = MCPManager()
+        err = mgr.enable(name, False)
+        if err:
+            conversation.notify(f"Error: {err}", title="/mcp disable", severity="error")
+            return
+
+        await conversation.post(MarkdownNote(f"**MCP Server '{name}' disabled.**"))
+
+    else:
+        await conversation.post(MarkdownNote(
+            "**MCP Server Management**\n\n"
+            "Usage:\n"
+            "- `/mcp list` - List all MCP servers\n"
+            "- `/mcp add <name> <url>` - Add an SSE MCP server\n"
+            "- `/mcp remove <name>` - Remove an MCP server\n"
+            "- `/mcp enable <name>` - Enable an MCP server\n"
+            "- `/mcp disable <name>` - Disable an MCP server"
+        ))
+
+
+def register_commands() -> None:
+    platform_commands.register("model", "Set onecode LLM model", _model, "<model name>")
+    platform_commands.register("provider", "Set onecode LLM provider", _provider, "<provider name>")
+    platform_commands.register("skill", "Manage skills (list, add, remove, enable, disable)", _skill, "list|add|remove [name]")
+    platform_commands.register("mcp", "Manage MCP servers (list, add, remove, enable, disable)", _mcp, "list|add|remove [name]")

package/onecode/config.py

@@ -0,0 +1,285 @@
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+import yaml
+
+
+CLOUD_DEV_HARNESS_DIR = Path.home() / ".onecode"
+GLOBAL_CONFIG_PATH = CLOUD_DEV_HARNESS_DIR / "onecode.config.yaml"
+
+
+@dataclass
+class ProviderConfig:
+    api_key: Optional[str] = None
+    endpoint: Optional[str] = None
+    models: list[str] = field(default_factory=list)
+
+
+@dataclass
+class ObservabilityConfig:
+    trace_enabled: bool = True
+    trace_exporter: str = "file"
+    otlp_endpoint: str = "http://localhost:4317"
+    trace_dir: str = "~/.onecode/traces"
+
+
+@dataclass
+class TuiConfig:
+    theme: str = "auto"
+    show_right_panel: bool = True
+    command_history_size: int = 100
+
+
+@dataclass
+class AttachmentsConfig:
+    max_size_mb: int = 10
+    allowed_extensions: list[str] = field(default_factory=lambda: [
+        ".txt", ".md", ".py", ".json", ".yaml", ".sql",
+    ])
+    sandbox_read: bool = True
+
+
+@dataclass
+class AgentConfig:
+    max_iterations: int = 20
+    timeout_seconds: int = 300
+    allow_shell_commands: bool = True
+    shell_command_whitelist: list[str] = field(default_factory=list)
+
+
+@dataclass
+class ModelAutoConfig:
+    simple_tasks: str = "minimax-2.7"
+    medium_tasks: str = "minimax-2.7"
+    complex_tasks: str = "minimax-2.7"
+
+
+@dataclass
+class CodebaseConfig:
+    enabled: bool = True
+    auto_retrieve: bool = True
+    chunk_strategy: str = "line"
+    chunk_lines: int = 50
+    chunk_overlap: int = 10
+    retriever: str = "bm25"
+    embedding_provider: str = ""
+    embedding_model: str = ""
+    top_k: int = 5
+    max_chunk_tokens: int = 500
+    exclude_patterns: list[str] = field(default_factory=lambda: [
+        "node_modules/**", "__pycache__/**", ".git/**",
+        ".venv/**", "venv/**", "dist/**", "build/**",
+        "*.min.*", "*.pyc", "*.egg-info/**", ".cdh/**",
+        ".opencode/**", ".claude/**", ".agents/**",
+        ".idea/**", ".vscode/**", ".DS_Store",
+    ])
+    include_extensions: list[str] = field(default_factory=lambda: [
+        ".py", ".js", ".ts", ".tsx", ".jsx", ".go", ".rs",
+        ".java", ".rb", ".php", ".c", ".cpp", ".h", ".hpp",
+        ".swift", ".kt", ".scala",
+        ".sql", ".yaml", ".yml", ".json", ".toml",
+        ".md", ".css", ".scss", ".html", ".svelte", ".vue",
+        ".sh", ".bash", ".zsh", ".fish",
+        ".tf", ".tfvars",
+    ])
+
+
+@dataclass
+class GlobalConfig:
+    default_mode: str = "build"
+    default_provider: str = "minimaxi"
+    default_model: str = "MiniMax-M2.7"
+
+    providers: dict[str, ProviderConfig] = field(default_factory=dict)
+    observability: ObservabilityConfig = field(default_factory=ObservabilityConfig)
+    attachments: AttachmentsConfig = field(default_factory=AttachmentsConfig)
+    agent: AgentConfig = field(default_factory=AgentConfig)
+    model_auto: ModelAutoConfig = field(default_factory=ModelAutoConfig)
+    current_project: str = ""
+    current_project_path: str = ""
+    log_level: str = "info"
+    session_auto_save: bool = True
+    codebase: CodebaseConfig = field(default_factory=CodebaseConfig)
+
+
+def _dict_to_dataclass(cls, data: dict):
+    if data is None:
+        return cls()
+    field_types = cls.__dataclass_fields__
+    kwargs = {}
+    for name, field_def in field_types.items():
+        if name in data:
+            val = data[name]
+            ftype = field_def.type
+            origin = getattr(ftype, "__origin__", None)
+            if origin is dict:
+                args = getattr(ftype, "__args__", ())
+                if len(args) == 2:
+                    _, val_type = args
+                    if hasattr(val_type, "__dataclass_fields__"):
+                        kwargs[name] = {k: _dict_to_dataclass(val_type, v) for k, v in val.items()}
+                    else:
+                        kwargs[name] = val
+                else:
+                    kwargs[name] = val
+            elif hasattr(ftype, "__dataclass_fields__"):
+                kwargs[name] = _dict_to_dataclass(ftype, val) if isinstance(val, dict) else ftype()
+            else:
+                kwargs[name] = val
+    return cls(**kwargs)
+
+
+def ensure_dirs():
+    dirs = [
+        CLOUD_DEV_HARNESS_DIR,
+        CLOUD_DEV_HARNESS_DIR / "sessions",
+        CLOUD_DEV_HARNESS_DIR / "skills",
+        CLOUD_DEV_HARNESS_DIR / "mcps",
+        CLOUD_DEV_HARNESS_DIR / "traces",
+        CLOUD_DEV_HARNESS_DIR / "logs",
+        CLOUD_DEV_HARNESS_DIR / "models",
+    ]
+    for d in dirs:
+        d.mkdir(parents=True, exist_ok=True)
+
+
+def load_config() -> GlobalConfig:
+    ensure_dirs()
+    if not GLOBAL_CONFIG_PATH.exists():
+        _write_default_config()
+    raw = yaml.safe_load(GLOBAL_CONFIG_PATH.read_text()) or {}
+    return _dict_to_dataclass(GlobalConfig, raw)
+
+
+def _write_default_config():
+    default = {
+        "default_mode": "build",
+        "default_provider": "minimaxi",
+        "default_model": "MiniMax-M2.7",
+        "providers": {
+            "anthropic": {
+                "api_key": "${ANTHROPIC_API_KEY}",
+                "endpoint": "https://api.anthropic.com/v1",
+                "models": [
+                    "claude-opus-4.7",
+                    "claude-opus-4.7-fast"
+                ],
+            },
+            "openai": {
+                "api_key": "${OPENAI_API_KEY}",
+                "endpoint": "https://api.openai.com/v1",
+                "models": ["gpt-5.5-pro", "gpt-5.5"],
+            },
+            "ollama": {
+                "endpoint": "http://localhost:11434",
+                "models": ["llama2", "codellama"],
+            },
+            "deepseek": {
+                "api_key": "${DEEPSEEK_API_KEY}",
+                "endpoint": "https://api.deepseek.com/v1",
+                "models": ["deepseek-v4-pro", "deepseek-v4-flash"],
+            },
+            "minimax": {
+                "api_key": "${MINIMAX_API_KEY}",
+                "endpoint": "https://api.minimax.com/v1",
+                "models": ["MiniMax-M2.7", "MiniMax-M2.5"],
+            },
+            "minimaxi": {
+                "api_key": "${MINMAXI_API_KEY}",
+                "endpoint": "https://api.minimaxi.com/v1",
+                "models": ["MiniMax-M2.7", "MiniMax-M2.5"],
+            },
+            "glm": {
+                "api_key": "${GLM_API_KEY}",
+                "endpoint": "https://open.bigmodel.cn/api/paas/v4",
+                "models": ["glm-5.1", "glm-5"],
+            },
+        },
+        "observability": {
+            "trace_enabled": True,
+            "trace_exporter": "file",
+            "otlp_endpoint": "http://localhost:4317",
+            "trace_dir": "~/.onecode/traces",
+        },
+        "attachments": {
+            "max_size_mb": 10,
+            "allowed_extensions": [".txt", ".md", ".py", ".json", ".yaml", ".sql"],
+            "sandbox_read": True,
+        },
+        "agent": {
+            "max_iterations": 20,
+            "timeout_seconds": 300,
+            "allow_shell_commands": True,
+            "shell_command_whitelist": [],
+        },
+        "model_auto": {
+            "simple_tasks": "minimax-2.7",
+            "medium_tasks": "minimax-2.7",
+            "complex_tasks": "minimax-2.7"
+        },
+        "current_project": "",
+        "current_project_path": "",
+        "log_level": "info",
+        "session_auto_save": True,
+        "codebase": {
+            "enabled": True,
+            "auto_retrieve": True,
+            "chunk_strategy": "line",
+            "chunk_lines": 50,
+            "chunk_overlap": 10,
+            "retriever": "bm25",
+            "top_k": 5,
+            "max_chunk_tokens": 500,
+            "exclude_patterns": [
+                "node_modules/**", "__pycache__/**", ".git/**",
+                ".venv/**", "venv/**", "dist/**", "build/**",
+                "*.min.*", "*.pyc", "*.egg-info/**", ".cdh/**",
+                ".opencode/**", ".claude/**", ".agents/**",
+                ".idea/**", ".vscode/**", ".DS_Store",
+            ],
+            "include_extensions": [
+                ".py", ".js", ".ts", ".tsx", ".jsx", ".go", ".rs",
+                ".java", ".rb", ".php", ".c", ".cpp", ".h", ".hpp",
+                ".swift", ".kt", ".scala",
+                ".sql", ".yaml", ".yml", ".json", ".toml",
+                ".md", ".css", ".scss", ".html", ".svelte", ".vue",
+                ".sh", ".bash", ".zsh", ".fish",
+                ".tf", ".tfvars",
+            ],
+        },
+    }
+    GLOBAL_CONFIG_PATH.write_text(yaml.dump(default, default_flow_style=False))
+
+
+def save_config(cfg: GlobalConfig):
+    GLOBAL_CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    raw = _dataclass_to_dict(cfg)
+    GLOBAL_CONFIG_PATH.write_text(yaml.dump(raw, default_flow_style=False))
+
+
+def _dataclass_to_dict(obj):
+    if hasattr(obj, "__dataclass_fields__"):
+        result = {}
+        for name, field_def in obj.__dataclass_fields__.items():
+            val = getattr(obj, name)
+            if hasattr(val, "__dataclass_fields__"):
+                result[name] = _dataclass_to_dict(val)
+            elif isinstance(val, dict) and val:
+                first_val = next(iter(val.values()), None)
+                if hasattr(first_val, "__dataclass_fields__"):
+                    result[name] = {k: _dataclass_to_dict(v) for k, v in val.items()}
+                else:
+                    result[name] = val
+            else:
+                result[name] = val
+        return result
+    return obj
+
+
+def resolve_env(value: str) -> str:
+    if value.startswith("${") and value.endswith("}"):
+        env_var = value[2:-1]
+        return os.environ.get(env_var, "")
+    return value