@scemoon/cdh 1.0.4 → 1.0.6

package/onecode/builtin_skills/skill-creator/SKILL.md

@@ -0,0 +1,106 @@
+---
+name: skill-creator
+description: Guide for creating new agent skills with proper conventions
+enabled: true
+triggers:
+  - create skill
+  - new skill
+  - scaffold skill
+  - write skill
+  - make a skill
+  - build a skill
+---
+
+# Skill Creator
+
+## When to Use
+
+When the user asks to create, scaffold, or design a new skill for the agent.
+
+## Skill Structure
+
+A skill consists of two files in a directory under `~/.onecode/skills/<name>/`:
+
+```
+skill-name/
+├── SKILL.md      # Instructions with YAML frontmatter
+└── skill.yaml    # Metadata config
+```
+
+## Naming Rules
+
+- Lowercase alphanumeric with single hyphens: `^[a-z0-9]+(-[a-z0-9]+)*$`
+- 1-64 characters
+- Good: `my-skill`, `code-review`, `deploy-aws`
+- Bad: `MySkill`, `my--skill`, `-skill`
+
+## SKILL.md Format
+
+Start with YAML frontmatter (between `---` markers), then markdown body:
+
+```markdown
+---
+name: my-skill
+description: What this skill does
+enabled: true
+triggers:
+  - phrase that triggers
+  - another trigger
+allowed_tools:
+  - Bash
+  - Read
+phases:
+  - plan
+  - verify
+---
+
+# My Skill
+
+## Instructions
+...
+```
+
+### Frontmatter Fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| name | yes | Skill name (matches dir name) |
+| description | yes | 1-1024 chars |
+| enabled | no | true/false (default true) |
+| triggers | no | Phrases that trigger this skill |
+| allowed_tools | no | Restrict which tools available |
+| arguments | no | Args accepted from user |
+| phases | no | Lifecycle phases this applies to |
+| license | no | License identifier |
+| compatibility | no | Version/engine compatibility |
+
+## Creating a Skill
+
+### Via CLI
+
+```bash
+cdh skill create my-skill --description "Description here"
+cdh skill create my-skill -d "Short description"
+```
+
+### Via API (Python)
+
+```python
+from onecode.skills import create_skill_scaffold
+create_skill_scaffold(skills_dir, name="my-skill", description="...")
+```
+
+### Manual
+
+1. Create `~/.onecode/skills/<name>/` directory
+2. Write `SKILL.md` with frontmatter + instructions
+3. Write `skill.yaml` with metadata
+4. Run `cdh skill list` to verify it shows up
+
+## Best Practices
+
+- Keep SKILL.md focused and actionable
+- Use clear headings and bullet lists
+- Include concrete examples and code snippets
+- Specify triggers so the agent knows when to activate
+- Test with `cdh skill enable/disable` toggle

package/onecode/builtin_skills/skill-creator/skill.yaml

@@ -0,0 +1,8 @@
+name: skill-creator
+description: >-
+  Meta-skill for creating new agent skills. Teaches the agent how to design,
+  scaffold, and write effective SKILL.md files with proper frontmatter,
+  conventions, and tool integration.
+version: 1.0.0
+enabled: true
+entry: SKILL.md

package/onecode/cli.py

@@ -2,12 +2,11 @@ import click
 import logging
 from logging.handlers import TimedRotatingFileHandler
 from pathlib import Path
-from typing import Optional
 
-from onecode.config import ensure_dirs, load_config, save_config
+from onecode.config import load_config, save_config
 
-LOG_DIR = Path.home() / ".cdh" / "logs"
-LOG_FILE = LOG_DIR / "cdh.log"
+LOG_DIR = Path.home() / ".onecode" / "logs"
+LOG_FILE = LOG_DIR / "onecode.log"
 LOG_BACKUP_COUNT = 7  # keep 7 days of history
 
 _VALID_LOG_LEVELS = {"DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"}
@@ -277,6 +276,73 @@ def skill_disable(name):
     _toggle_skill(name, enabled=False)
 
 
+@skill.command("create")
+@click.argument("name")
+@click.option("--description", "-d", default="", help="Skill description")
+def skill_create(name, description):
+    """Create a new skill scaffold.
+
+    \b
+    Creates SKILL.md and skill.yaml in ~/.onecode/skills/<name>/.
+    Edit the generated SKILL.md to add your instructions.
+
+    \b
+    Example:
+      cdh skill create my-skill -d "My custom skill"
+    """
+    from onecode.skills.create import create_skill_scaffold
+    from onecode.skills.manager import SkillManager
+    from onecode.skills.model import Skill as SkillModel
+
+    valid, err = SkillModel.validate_name(name)
+    if not valid:
+        click.echo(f"Error: Invalid skill name: {err}")
+        return
+    if description:
+        valid, err = SkillModel.validate_description(description)
+        if not valid:
+            click.echo(f"Error: Invalid description: {err}")
+            return
+
+    mgr = SkillManager()
+    err = create_skill_scaffold(mgr.skills_dir, name, description or f"A skill for {name}")
+    if err:
+        click.echo(f"Error: {err}")
+    else:
+        click.echo(f"Skill '{name}' created at {mgr.skills_dir / name}")
+        click.echo(f"  Edit {mgr.skills_dir / name / 'SKILL.md'} to add instructions.")
+
+
+@skill.command("search")
+@click.argument("keyword")
+def skill_search(keyword):
+    """Search installed skills by keyword.
+
+    Matches against name, description, triggers, and phases.
+    Case-insensitive.
+
+    \b
+    Example:
+      cdh skill search browser
+    """
+    from onecode.skills.loader import SkillLoader
+
+    loader = SkillLoader()
+    results = loader.search(keyword)
+
+    if not results:
+        click.echo(f"No skills found matching '{keyword}'.")
+        return
+
+    click.echo(f"Skills matching '{keyword}':")
+    for s in results:
+        status = "[enabled]" if s.enabled else "[disabled]"
+        click.echo(f"  {status} {s.name}")
+        if s.description:
+            click.echo(f"           {s.description}")
+    click.echo(f"\nTotal: {len(results)} match(es)")
+
+
 def _toggle_skill(name: str, enabled: bool):
     import yaml
     from onecode.skills.loader import SkillLoader
@@ -373,6 +439,56 @@ def config_skill_disable(name):
     _toggle_skill(name, enabled=False)
 
 
+@config_skill.command("create")
+@click.argument("name")
+@click.option("--description", "-d", default="", help="Skill description")
+def config_skill_create(name, description):
+    """Create a new skill scaffold (alias for cdh skill create)."""
+    from onecode.skills.create import create_skill_scaffold
+    from onecode.skills.manager import SkillManager
+    from onecode.skills.model import Skill as SkillModel
+
+    valid, err = SkillModel.validate_name(name)
+    if not valid:
+        click.echo(f"Error: Invalid skill name: {err}")
+        return
+    if description:
+        valid, err = SkillModel.validate_description(description)
+        if not valid:
+            click.echo(f"Error: Invalid description: {err}")
+            return
+
+    mgr = SkillManager()
+    err = create_skill_scaffold(mgr.skills_dir, name, description or f"A skill for {name}")
+    if err:
+        click.echo(f"Error: {err}")
+    else:
+        click.echo(f"Skill '{name}' created at {mgr.skills_dir / name}")
+        click.echo(f"  Edit {mgr.skills_dir / name / 'SKILL.md'} to add instructions.")
+
+
+@config_skill.command("search")
+@click.argument("keyword")
+def config_skill_search(keyword):
+    """Search installed skills by keyword (alias for cdh skill search)."""
+    from onecode.skills.loader import SkillLoader
+
+    loader = SkillLoader()
+    results = loader.search(keyword)
+
+    if not results:
+        click.echo(f"No skills found matching '{keyword}'.")
+        return
+
+    click.echo(f"Skills matching '{keyword}':")
+    for s in results:
+        status = "[enabled]" if s.enabled else "[disabled]"
+        click.echo(f"  {status} {s.name}")
+        if s.description:
+            click.echo(f"           {s.description}")
+    click.echo(f"\nTotal: {len(results)} match(es)")
+
+
 @cli.group(invoke_without_command=True)
 def mcp():
     """Manage MCP (Model Context Protocol) servers.
@@ -619,7 +735,7 @@ def codebase():
 def codebase_index(force: bool, path: str):
     """Index project files for codebase search."""
     import asyncio
-    from onecode.codebase import CodebaseEngine, CodebaseConfig
+    from onecode.codebase import CodebaseEngine
 
     project_dir = Path(path).resolve()
     if not project_dir.is_dir():
@@ -630,7 +746,6 @@ def codebase_index(force: bool, path: str):
     engine = CodebaseEngine(project_dir, cfg.codebase)
     result = asyncio.run(engine.ensure_indexed(force=force))
 
-    total = result.total_files if hasattr(result, 'total_files') else 0
     click.echo(
         f"Indexed {project_dir.name}: "
         f"{result.indexed_files} files, "
@@ -721,6 +836,71 @@ def codebase_reindex(path: str):
     )
 
 
+@cli.group()
+def memory():
+    """Manage long-term memory.
+
+    \b
+    Memory stores conversation history with BM25 keyword recall.
+    Use `cdh memory status` to view memory usage and `cdh memory clear` to reset.
+    """
+    pass
+
+
+@memory.command("status")
+def memory_status():
+    """Show memory usage statistics."""
+    from onecode.memory.backend import MemoryBackend
+
+    backend = MemoryBackend()
+    counts = backend.count_by_layer()
+    total = sum(counts.values())
+    click.echo(f"Total entries: {total}")
+    for layer, count in counts.items():
+        click.echo(f"  {layer}: {count}")
+    if total == 0:
+        click.echo("  (no memories stored yet)")
+
+
+@memory.command("clear")
+@click.option("--layer", default=None, help="Layer to clear (default: all layers)")
+def memory_clear(layer: str):
+    """Clear memory entries."""
+    from onecode.memory import AgentMemory
+    from onecode.memory.pyramid import MemoryLayer
+
+    am = AgentMemory()
+    if layer:
+        layers_to_clear = [l for l in MemoryLayer if l.value == layer]
+    else:
+        layers_to_clear = list(MemoryLayer)
+    removed = 0
+    for l in layers_to_clear:
+        entries = am.pyramid.list_by_layer(l)
+        for e in entries:
+            am.pyramid._layers[l].remove(e)
+            am.backend.delete_entry(e.id)
+            removed += 1
+    click.echo(f"Cleared {removed} memory entries.")
+
+
+@memory.command("count")
+@click.option("--layer", default=None, help="Layer to count (default: all layers)")
+def memory_count(layer: str):
+    """Count memory entries."""
+    from onecode.memory.backend import MemoryBackend
+
+    backend = MemoryBackend()
+    counts = backend.count_by_layer()
+    if layer:
+        click.echo(f"Entries in {layer}: {counts.get(layer, 0)}")
+    else:
+        total = sum(counts.values())
+        click.echo(f"Total entries: {total}")
+        for ly, count in sorted(counts.items()):
+            click.echo(f"  {ly}: {count}")
+
+
 @cli.command()
 @click.argument("command", required=False)
 @click.option("--list", "list_commands", is_flag=True, help="List all available commands")

package/onecode/codebase/chunker.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import os
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Optional
 
 
 _LANG_MAP: dict[str, str] = {
@@ -64,10 +63,6 @@ def detect_language(file_path: str) -> str:
 
 def chunk_file(file_path: Path, strategy: str = "line",
                chunk_lines: int = 50, overlap: int = 10) -> list[CodeChunk]:
-    if strategy == "line":
-        return _chunk_by_lines(file_path, chunk_lines, overlap)
-    if strategy == "ast":
-        return _chunk_by_lines(file_path, chunk_lines, overlap)
     return _chunk_by_lines(file_path, chunk_lines, overlap)
 
 

package/onecode/codebase/indexer.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import logging
 import os
 import time
@@ -82,7 +83,19 @@ class CodebaseIndexer:
         files = self.walk_files()
         result.total_files = len(files)
 
-        for fpath in files:
+        # Yield control to the event loop periodically so:
+        #   - CancelledError injected by ``prompt_task.cancel()`` during a
+        #     subagent chat_stream can actually propagate (without this
+        #     the synchronous SQLite/chunker loop below would monopolise
+        #     the event loop and a stuck subagent could never be stopped).
+        #   - other coroutines (e.g. the ACP stdin loop, TUI refresh) keep
+        #     getting scheduled while a long indexing pass runs.
+        _YIELD_EVERY = 16
+
+        for i, fpath in enumerate(files):
+            if i and (i % _YIELD_EVERY) == 0:
+                await asyncio.sleep(0)
+
             if not force and not self.needs_reindex(fpath):
                 result.skipped_files += 1
                 continue

package/onecode/codebase/retriever.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import json
 import logging
 import math
 from typing import Optional
@@ -147,11 +146,23 @@ async def _get_batch_embeddings(texts: list[str], config: CodebaseConfig) -> lis
     provider_name = config.embedding_provider or cfg.default_provider
     pcfg = cfg.providers.get(provider_name)
 
+    MAX_EMBED_CHUNKS = 500
+    if len(texts) > MAX_EMBED_CHUNKS:
+        import logging
+        logging.getLogger(__name__).warning(
+            "Embedding requested on %d chunks (max=%d); truncating to avoid timeout",
+            len(texts), MAX_EMBED_CHUNKS,
+        )
+        texts = texts[:MAX_EMBED_CHUNKS]
+
     if provider_name == "ollama" and pcfg:
         embs = await _ollama_batch_embed(texts, pcfg.endpoint or "http://localhost:11434")
     else:
         embs = []
-        for t in texts:
+        for i, t in enumerate(texts):
+            if i > 0 and i % 16 == 0:
+                import asyncio
+                await asyncio.sleep(0)
             emb = await _get_embedding(t, config)
             embs.append(emb)
 

package/onecode/codebase/storage.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
-import os
+import hashlib
 from pathlib import Path
-from typing import Optional
 
 from sqlalchemy import Column, String, Text, Integer, Float, create_engine, Index
-from sqlalchemy.orm import declarative_base, sessionmaker, Session
+from sqlalchemy.orm import declarative_base, sessionmaker
 
 from onecode.codebase.chunker import CodeChunk
+from onecode.config import ONECODE_DIR
 
 Base = declarative_base()
 
@@ -31,7 +31,8 @@ class ChunkRecord(Base):
 
 class CodebaseStorage:
     def __init__(self, project_dir: Path):
-        db_dir = project_dir / ".cdh" / "codebase"
+        project_key = hashlib.sha256(str(project_dir.resolve()).encode()).hexdigest()[:16]
+        db_dir = ONECODE_DIR / "codebase" / "indexes" / project_key
         db_dir.mkdir(parents=True, exist_ok=True)
         self.db_path = db_dir / "index.db"
         self.engine = create_engine(f"sqlite:///{self.db_path}", echo=False)

package/onecode/commands.py

@@ -310,6 +310,51 @@ async def _skill(conversation: "Conversation", parameters: str) -> None:
         await _skill(conversation, "list")
         return
 
+    if sub == "create":
+        name = rest.strip()
+        if not name:
+            conversation.notify("Usage: /onecode:skill create <name>", title="/onecode:skill create", severity="error")
+            return
+        from onecode.skills.model import Skill as SkillModel
+        valid, err_msg = SkillModel.validate_name(name)
+        if not valid:
+            conversation.notify(f"Invalid name: {err_msg}", title="/onecode:skill create", severity="error")
+            return
+        mgr = SkillManager()
+        if mgr.get(name):
+            conversation.notify(f"Skill '{name}' already exists", title="/onecode:skill create", severity="error")
+            return
+        err = create_skill_scaffold(mgr.skills_dir, name, f"A skill for {name}")
+        if err:
+            conversation.notify(f"Error: {err}", title="/onecode:skill create", severity="error")
+            return
+        await _post(
+            conversation,
+            f"**Skill '{name}' created**\n\n"
+            f"- location: `{mgr.skills_dir / name}`\n"
+            f"- edit `SKILL.md` to add instructions\n"
+            f"- then `/onecode:skill list` to confirm",
+        )
+        return
+
+    if sub in ("search", "find"):
+        keyword = rest.strip()
+        if not keyword:
+            conversation.notify("Usage: /onecode:skill search <keyword>", title="/onecode:skill search", severity="error")
+            return
+        results = SkillLoader().search(keyword)
+        if not results:
+            await _post(conversation, f"**Skill Search: `{keyword}`**\n\n_No matches found._")
+            return
+        lines = [f"**Skill Search: `{keyword}`**\n"]
+        for i, s in enumerate(results, 1):
+            marker = "✓" if s.enabled else "✗"
+            desc = s.description or "(no description)"
+            lines.append(f"- `{i}) {marker}` **{s.name}** — {desc}")
+        lines.append(f"\n{len(results)} match(es)")
+        await _post(conversation, "\n".join(lines))
+        return
+
     await _post(conversation, _HELP_SKILL)
 
 
@@ -317,14 +362,17 @@ _HELP_SKILL = (
     "**/onecode:skill** — manage installed skills\n\n"
     "**Sub-commands**\n"
     "- `(none)` or `list` — show all skills with status\n"
+    "- `create <name>` — scaffold a new skill\n"
+    "- `search <keyword>` — search skills by keyword\n"
     "- `enable <name|n>` — turn a skill on\n"
     "- `disable <name|n>` — turn a skill off\n"
-    "- `add <name>` — scaffold a new skill\n"
+    "- `add <name>` — scaffold a new skill (alias for create)\n"
     "- `remove <name|n>` — delete a skill\n\n"
     "**Examples**\n"
     "- `/onecode:skill` — list\n"
-    "- `/onecode:skill enable 2` — enable the skill at index 2 from the list\n"
-    "- `/onecode:skill add my-skill` — scaffold a new skill named `my-skill`"
+    "- `/onecode:skill create my-skill` — scaffold a new skill\n"
+    "- `/onecode:skill search browser` — find browser-related skills\n"
+    "- `/onecode:skill enable 2` — enable the skill at index 2"
 )
 
 
@@ -349,7 +397,6 @@ async def _mcp(conversation: "Conversation", parameters: str) -> None:
             )
             return
         lines = ["**MCP Servers**\n"]
-        names = [s.get("name", "?") for s in servers]
         for i, s in enumerate(servers, 1):
             name = s.get("name", "?")
             transport = s.get("transport", "sse")
@@ -473,6 +520,28 @@ def _resolve_indexed_name(conversation, raw, items, sub_label):
     return None
 
 
+# ── clear-todos ──────────────────────────────────────────────────────────
+
+
+async def _clear_todos(conversation: "Conversation", parameters: str) -> None:
+    """Clear all todos via the agent's session/clear_todos RPC."""
+    agent = conversation.agent
+    if agent is None:
+        conversation.notify("No active agent session", title="/clear-todos", severity="error")
+        return
+    if not hasattr(agent, "acp_session_clear_todos"):
+        conversation.notify("Agent does not support clear-todos", title="/clear-todos", severity="error")
+        return
+    try:
+        result = await agent.acp_session_clear_todos()
+        if result and result.get("cleared"):
+            conversation.notify("All todos cleared", title="/clear-todos")
+        else:
+            conversation.notify("Failed to clear todos", title="/clear-todos", severity="error")
+    except Exception as e:
+        conversation.notify(f"Failed to clear todos: {e}", title="/clear-todos", severity="error")
+
+
 # ── registration ──────────────────────────────────────────────────────
 
 
@@ -509,13 +578,19 @@ def register_commands() -> None:
     )
     platform_commands.register(
         "skill",
-        "Manage skills: list, enable, disable, add, remove (accepts name or list number)",
+        "Manage skills: list, create, search, enable, disable, add, remove (accepts name or list number)",
         _skill,
-        "list|enable|disable|add|remove [name|n]",
+        "list|create|search|enable|disable|add|remove [name|n]",
     )
     platform_commands.register(
         "mcp",
         "Manage MCP servers: list, add, enable, disable, remove (accepts name or list number)",
         _mcp,
         "list|add|enable|disable|remove [name|n]",
+    )
+    platform_commands.register(
+        "clear-todos",
+        "Clear all plan todos — starts a fresh blank plan",
+        _clear_todos,
+        "(no args)",
     )