dulus 0.2.0__py3-none-any.whl

skill/tools.py

@@ -0,0 +1,110 @@
+"""Skill tool: lets the model invoke skills by name via tool call."""
+from __future__ import annotations
+
+from tool_registry import ToolDef, register_tool
+from .loader import find_skill, load_skills, substitute_arguments
+
+
+_SKILL_SCHEMA = {
+    "name": "Skill",
+    "description": (
+        "Invoke a named skill (reusable prompt template). "
+        "Use SkillList to see available skills and their triggers."
+    ),
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "name": {
+                "type": "string",
+                "description": "Skill name (e.g. 'commit', 'review')",
+            },
+            "args": {
+                "type": "string",
+                "description": "Arguments to pass to the skill (replaces $ARGUMENTS)",
+                "default": "",
+            },
+        },
+        "required": ["name"],
+    },
+}
+
+_SKILL_LIST_SCHEMA = {
+    "name": "SkillList",
+    "description": "List all available skills with their names, triggers, and descriptions.",
+    "input_schema": {
+        "type": "object",
+        "properties": {},
+        "required": [],
+    },
+}
+
+
+def _skill_tool(params: dict, config: dict) -> str:
+    """Execute a skill by name and return its output."""
+    skill_name = params.get("name", "").strip()
+    args = params.get("args", "")
+
+    # Look up by name first, then by trigger
+    skill = None
+    for s in load_skills():
+        if s.name == skill_name:
+            skill = s
+            break
+    if skill is None:
+        skill = find_skill(skill_name)
+    if skill is None:
+        names = [s.name for s in load_skills()]
+        return f"Error: skill '{skill_name}' not found. Available: {', '.join(names)}"
+
+    rendered = substitute_arguments(skill.prompt, args, skill.arguments)
+    message = f"[Skill: {skill.name}]\n\n{rendered}"
+
+    # Run inline via agent and collect text output
+    import agent as _agent
+    system_prompt = config.get("_system_prompt", "")
+
+    # Collect output text
+    output_parts: list[str] = []
+    sub_state = _agent.AgentState()
+    sub_config = {**config, "_depth": config.get("_depth", 0) + 1}
+    try:
+        for event in _agent.run(message, sub_state, sub_config, system_prompt):
+            if hasattr(event, "text"):
+                output_parts.append(event.text)
+    except Exception as e:
+        return f"Skill execution error: {e}"
+
+    return "".join(output_parts) or "(skill completed with no text output)"
+
+
+def _skill_list_tool(params: dict, config: dict) -> str:
+    skills = load_skills()
+    if not skills:
+        return "No skills available."
+    lines = ["Available skills:\n"]
+    for s in skills:
+        triggers = ", ".join(s.triggers)
+        hint = f"  args: {s.argument_hint}" if s.argument_hint else ""
+        when = f"\n    when: {s.when_to_use}" if s.when_to_use else ""
+        lines.append(f"- **{s.name}** [{triggers}]{hint}\n  {s.description}{when}")
+    return "\n".join(lines)
+
+
+def _register() -> None:
+    register_tool(ToolDef(
+        name="Skill",
+        schema=_SKILL_SCHEMA,
+        func=_skill_tool,
+        read_only=False,
+        concurrent_safe=False,
+    ))
+    register_tool(ToolDef(
+        name="SkillList",
+        schema=_SKILL_LIST_SCHEMA,
+        func=_skill_list_tool,
+        read_only=True,
+        concurrent_safe=True,
+    ))
+
+
+_register()

skills.py

@@ -0,0 +1,14 @@
+"""Backward-compatibility shim — real implementation is in skill/ package."""
+from skill.loader import (  # noqa: F401
+    SkillDef,
+    load_skills,
+    find_skill,
+    substitute_arguments,
+    _parse_skill_file,
+    _parse_list_field,
+)
+from skill.executor import execute_skill  # noqa: F401
+
+# Legacy constant — kept for tests that patch it
+from skill.loader import _get_skill_paths as _gsp
+SKILL_PATHS = _gsp()

spinner.py

@@ -0,0 +1,42 @@
+"""Shared spinner phrases for Dulus's tool/debate spinners.
+
+Centralized so dulus.py and ui/render.py stay in sync.
+"""
+
+TOOL_SPINNER_PHRASES = [
+    "⚡ Rewriting light speed...",
+    "🏁 Winning a race against light...",
+    "🤔 Who is Barry Allen?...",
+    "🤔 Who is KevRojo?...",
+    "🦅 Dropping from the stratosphere...",
+    "💨 Leaving electrons behind...",
+    "🌍 Orbiting the codebase...",
+    "⏱️ Breaking the sound barrier...",
+    "🔥 Faster than a hot reload...",
+    "🚀 Terminal velocity reached...",
+    "🦅 Sharpening talons on the AST...",
+    "🏎️ Shifting to 6th gear...",
+    "⚡ Speed force activated...",
+    "🌪️ Blitzing through the bytecode...",
+    "💫 Bending spacetime...",
+    "🦅 Preying on bugs from above...",
+    "👁️ Dulus vision engaged...",
+    "🍗 Hunting for memory leaks...",
+    "🪶 Shedding legacy code...",
+    "🕹️ Try-catching mid-flight...",
+    "🥚 Hatching a master plan...",
+    "⚡ I-I-I'm... I-I'm... I'm fast...",
+    "🔮 Looking at your code from the future...",
+    "☕ If I'm taking so long, don't worry, I'm just talking to your mom...",
+]
+
+DEBATE_SPINNER_PHRASES = [
+    "⚔️  Experts taking their positions...",
+    "🧠  Experts formulating arguments...",
+    "🗣️  Debate in progress...",
+    "⚖️  Weighing the evidence...",
+    "💡  Building counter-arguments...",
+    "🔥  Debate heating up...",
+    "📜  Drafting the consensus...",
+    "🎯  Finding common ground...",
+]

string_utils.py

@@ -0,0 +1,42 @@
+"""String utilities — adapted from kimi-cli."""
+from __future__ import annotations
+
+import random
+import re
+import string
+
+_NEWLINE_RE = re.compile(r"[\r\n]+")
+
+
+def shorten(text: str, *, width: int, placeholder: str = "…") -> str:
+    """Shorten text to at most *width* characters.
+
+    Normalises whitespace, then truncates — preferring a word boundary
+    when one exists near the cut point, but falling back to a hard cut
+    so that CJK text without spaces won't collapse to just the placeholder.
+    """
+    text = " ".join(text.split())
+    if len(text) <= width:
+        return text
+    cut = width - len(placeholder)
+    if cut <= 0:
+        return text[:width]
+    space = text.rfind(" ", 0, cut + 1)
+    if space > 0:
+        cut = space
+    return text[:cut].rstrip() + placeholder
+
+
+def shorten_middle(text: str, width: int, remove_newline: bool = True) -> str:
+    """Shorten the text by inserting ellipsis in the middle."""
+    if len(text) <= width:
+        return text
+    if remove_newline:
+        text = _NEWLINE_RE.sub(" ", text)
+    return text[: width // 2] + "..." + text[-width // 2 :]
+
+
+def random_string(length: int = 8) -> str:
+    """Generate a random string of fixed length."""
+    letters = string.ascii_lowercase
+    return "".join(random.choice(letters) for _ in range(length))

subagent.py

@@ -0,0 +1,11 @@
+"""Backward-compatibility shim — real implementation is in multi_agent/subagent.py."""
+from multi_agent.subagent import (  # noqa: F401
+    AgentDefinition,
+    SubAgentTask,
+    SubAgentManager,
+    load_agent_definitions,
+    get_agent_definition,
+    _extract_final_text,
+    _agent_run,
+    _BUILTIN_AGENTS,
+)

task/__init__.py

@@ -0,0 +1,12 @@
+"""Task system for dulus."""
+from .types import Task, TaskStatus
+from .store import (
+    create_task, get_task, list_tasks, update_task,
+    delete_task, clear_all_tasks, reload_from_disk,
+)
+
+__all__ = [
+    "Task", "TaskStatus",
+    "create_task", "get_task", "list_tasks", "update_task",
+    "delete_task", "clear_all_tasks", "reload_from_disk",
+]

task/store.py

@@ -0,0 +1,199 @@
+"""Thread-safe task store: in-memory dict persisted to .dulus/tasks.json."""
+from __future__ import annotations
+
+import json
+import threading
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from .types import Task, TaskStatus
+
+_lock = threading.Lock()
+
+# Tasks are keyed by ID, stored per session in <cwd>/.dulus/tasks.json
+# The store is kept in memory; we reload from disk on first access.
+
+_tasks: dict[str, Task] = {}
+_loaded = False
+
+
+# ── persistence ───────────────────────────────────────────────────────────────
+
+def _tasks_file() -> Path:
+    return Path.cwd() / ".dulus-context" / "tasks.json"
+
+
+def _load() -> None:
+    global _loaded
+    if _loaded:
+        return
+    f = _tasks_file()
+    if f.exists():
+        try:
+            data = json.loads(f.read_text())
+            for item in data.get("tasks", []):
+                t = Task.from_dict(item)
+                _tasks[t.id] = t
+        except Exception:
+            pass
+    _loaded = True
+
+
+def _save() -> None:
+    f = _tasks_file()
+    f.parent.mkdir(parents=True, exist_ok=True)
+    data = {"tasks": [t.to_dict() for t in _tasks.values()]}
+    f.write_text(json.dumps(data, indent=2))
+
+
+def _next_id() -> str:
+    """Generate a short sequential numeric ID."""
+    if not _tasks:
+        return "1"
+    max_id = max((int(k) for k in _tasks if k.isdigit()), default=0)
+    return str(max_id + 1)
+
+
+# ── public API ────────────────────────────────────────────────────────────────
+
+def create_task(
+    subject: str,
+    description: str,
+    active_form: str = "",
+    metadata: dict[str, Any] | None = None,
+) -> Task:
+    with _lock:
+        _load()
+        task = Task(
+            id=_next_id(),
+            subject=subject,
+            description=description,
+            active_form=active_form,
+            metadata=metadata or {},
+        )
+        _tasks[task.id] = task
+        _save()
+        return task
+
+
+def get_task(task_id: str) -> Task | None:
+    with _lock:
+        _load()
+        return _tasks.get(str(task_id))
+
+
+def list_tasks() -> list[Task]:
+    with _lock:
+        _load()
+        return list(_tasks.values())
+
+
+def update_task(
+    task_id: str,
+    subject: str | None = None,
+    description: str | None = None,
+    status: str | None = None,
+    active_form: str | None = None,
+    owner: str | None = None,
+    add_blocks: list[str] | None = None,
+    add_blocked_by: list[str] | None = None,
+    metadata: dict[str, Any] | None = None,
+) -> tuple[Task | None, list[str]]:
+    """Update a task. Returns (updated_task, list_of_updated_fields)."""
+    with _lock:
+        _load()
+        task = _tasks.get(str(task_id))
+        if task is None:
+            return None, []
+
+        updated_fields: list[str] = []
+
+        if subject is not None and subject != task.subject:
+            task.subject = subject
+            updated_fields.append("subject")
+
+        if description is not None and description != task.description:
+            task.description = description
+            updated_fields.append("description")
+
+        if active_form is not None and active_form != task.active_form:
+            task.active_form = active_form
+            updated_fields.append("active_form")
+
+        if owner is not None and owner != task.owner:
+            task.owner = owner
+            updated_fields.append("owner")
+
+        if status is not None:
+            try:
+                new_status = TaskStatus(status)
+            except ValueError:
+                new_status = None
+            if new_status is not None and new_status != task.status:
+                task.status = new_status
+                updated_fields.append("status")
+
+        if metadata is not None:
+            for k, v in metadata.items():
+                if v is None:
+                    task.metadata.pop(k, None)
+                else:
+                    task.metadata[k] = v
+            updated_fields.append("metadata")
+
+        if add_blocks:
+            new_blocks = [b for b in add_blocks if b not in task.blocks]
+            if new_blocks:
+                task.blocks.extend(new_blocks)
+                # Also register the reverse edge on the target tasks
+                for b_id in new_blocks:
+                    target = _tasks.get(str(b_id))
+                    if target and str(task_id) not in target.blocked_by:
+                        target.blocked_by.append(str(task_id))
+                updated_fields.append("blocks")
+
+        if add_blocked_by:
+            new_bb = [b for b in add_blocked_by if b not in task.blocked_by]
+            if new_bb:
+                task.blocked_by.extend(new_bb)
+                # Also register the reverse edge
+                for blocker_id in new_bb:
+                    blocker = _tasks.get(str(blocker_id))
+                    if blocker and str(task_id) not in blocker.blocks:
+                        blocker.blocks.append(str(task_id))
+                updated_fields.append("blocked_by")
+
+        if updated_fields:
+            task.updated_at = datetime.now().isoformat()
+            _save()
+
+        return task, updated_fields
+
+
+def delete_task(task_id: str) -> bool:
+    with _lock:
+        _load()
+        task_id = str(task_id)
+        if task_id not in _tasks:
+            return False
+        del _tasks[task_id]
+        _save()
+        return True
+
+
+def clear_all_tasks() -> None:
+    """Remove all tasks (used in tests)."""
+    with _lock:
+        _tasks.clear()
+        _save()
+
+
+def reload_from_disk() -> None:
+    """Force reload from disk (used in tests)."""
+    global _loaded
+    with _lock:
+        _tasks.clear()
+        _loaded = False
+        _load()

task/tools.py

@@ -0,0 +1,265 @@
+"""Task tools: TaskCreate, TaskUpdate, TaskGet, TaskList — registered into tool_registry."""
+from __future__ import annotations
+
+from tool_registry import ToolDef, register_tool
+from .store import create_task, get_task, list_tasks, update_task, delete_task
+from .types import TaskStatus
+
+
+# ── Schemas ───────────────────────────────────────────────────────────────────
+
+_TASK_CREATE_SCHEMA = {
+    "name": "TaskCreate",
+    "description": (
+        "Create a new task in the task list. "
+        "Use this to track work items, to-dos, and multi-step plans. "
+        "Returns the new task's ID and subject."
+    ),
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "subject": {
+                "type": "string",
+                "description": "A brief title for the task",
+            },
+            "description": {
+                "type": "string",
+                "description": "What needs to be done",
+            },
+            "active_form": {
+                "type": "string",
+                "description": (
+                    "Present-continuous label shown while in_progress "
+                    "(e.g. 'Running tests', 'Writing docs')"
+                ),
+            },
+            "metadata": {
+                "type": "object",
+                "description": "Arbitrary key-value metadata to attach to the task",
+            },
+        },
+        "required": ["subject", "description"],
+    },
+}
+
+_TASK_UPDATE_SCHEMA = {
+    "name": "TaskUpdate",
+    "description": (
+        "Update an existing task. Can change subject, description, status, owner, "
+        "dependency edges (blocks / blocked_by), and metadata. "
+        "Set status='deleted' to remove the task. "
+        "Valid statuses: pending, in_progress, completed, cancelled, deleted."
+    ),
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "task_id": {
+                "type": "string",
+                "description": "The ID of the task to update",
+            },
+            "subject": {
+                "type": "string",
+                "description": "New title for the task",
+            },
+            "description": {
+                "type": "string",
+                "description": "New description for the task",
+            },
+            "status": {
+                "type": "string",
+                "enum": ["pending", "in_progress", "completed", "cancelled", "deleted"],
+                "description": "New status ('deleted' removes the task)",
+            },
+            "active_form": {
+                "type": "string",
+                "description": "Present-continuous label while in_progress",
+            },
+            "owner": {
+                "type": "string",
+                "description": "Agent/user responsible for this task",
+            },
+            "add_blocks": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Task IDs that this task now blocks",
+            },
+            "add_blocked_by": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Task IDs that block this task",
+            },
+            "metadata": {
+                "type": "object",
+                "description": "Keys to merge into task metadata (null value = delete key)",
+            },
+        },
+        "required": ["task_id"],
+    },
+}
+
+_TASK_GET_SCHEMA = {
+    "name": "TaskGet",
+    "description": "Retrieve a single task by ID. Returns full task details.",
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "task_id": {
+                "type": "string",
+                "description": "The ID of the task to retrieve",
+            },
+        },
+        "required": ["task_id"],
+    },
+}
+
+_TASK_LIST_SCHEMA = {
+    "name": "TaskList",
+    "description": (
+        "List all tasks. Returns id, subject, status, owner, and pending blockers. "
+        "Use this to review the current plan or find the next available task."
+    ),
+    "input_schema": {
+        "type": "object",
+        "properties": {},
+        "required": [],
+    },
+}
+
+
+# ── Implementations ────────────────────────────────────────────────────────────
+
+def _task_create(subject: str, description: str, active_form: str = "", metadata: dict = None) -> str:
+    task = create_task(subject, description, active_form=active_form, metadata=metadata)
+    return f"Task #{task.id} created: {task.subject}"
+
+
+def _task_update(
+    task_id: str,
+    subject: str = None,
+    description: str = None,
+    status: str = None,
+    active_form: str = None,
+    owner: str = None,
+    add_blocks: list = None,
+    add_blocked_by: list = None,
+    metadata: dict = None,
+) -> str:
+    # Handle deletion
+    if status == "deleted":
+        ok = delete_task(task_id)
+        if ok:
+            return f"Task #{task_id} deleted."
+        return f"Error: task #{task_id} not found."
+
+    task, updated_fields = update_task(
+        task_id,
+        subject=subject,
+        description=description,
+        status=status,
+        active_form=active_form,
+        owner=owner,
+        add_blocks=add_blocks or [],
+        add_blocked_by=add_blocked_by or [],
+        metadata=metadata,
+    )
+    if task is None:
+        return f"Error: task #{task_id} not found."
+    if not updated_fields:
+        return f"Task #{task_id}: no changes (fields already match)."
+    return f"Task #{task_id} updated — changed: {', '.join(updated_fields)}."
+
+
+def _task_get(task_id: str) -> str:
+    task = get_task(task_id)
+    if task is None:
+        return f"Task #{task_id} not found."
+    lines = [
+        f"Task #{task.id}: {task.subject}",
+        f"Status:      {task.status.value}",
+        f"Description: {task.description}",
+    ]
+    if task.owner:
+        lines.append(f"Owner:       {task.owner}")
+    if task.active_form:
+        lines.append(f"Active form: {task.active_form}")
+    if task.blocked_by:
+        lines.append(f"Blocked by:  #{', #'.join(task.blocked_by)}")
+    if task.blocks:
+        lines.append(f"Blocks:      #{', #'.join(task.blocks)}")
+    if task.metadata:
+        lines.append(f"Metadata:    {task.metadata}")
+    lines.append(f"Created:     {task.created_at[:19]}")
+    lines.append(f"Updated:     {task.updated_at[:19]}")
+    return "\n".join(lines)
+
+
+def _task_list() -> str:
+    tasks = list_tasks()
+    if not tasks:
+        return "No tasks."
+    resolved = {t.id for t in tasks if t.status == TaskStatus.COMPLETED}
+    lines = []
+    for task in tasks:
+        pending_blockers = [b for b in task.blocked_by if b not in resolved]
+        owner_str   = f" ({task.owner})" if task.owner else ""
+        blocked_str = f" [blocked by #{', #'.join(pending_blockers)}]" if pending_blockers else ""
+        lines.append(
+            f"#{task.id} [{task.status.value}] {task.status_icon()} "
+            f"{task.subject}{owner_str}{blocked_str}"
+        )
+    return "\n".join(lines)
+
+
+# ── Registration ───────────────────────────────────────────────────────────────
+
+def _register() -> None:
+    defs = [
+        ToolDef(
+            name="TaskCreate",
+            schema=_TASK_CREATE_SCHEMA,
+            func=lambda p, c: _task_create(
+                p["subject"],
+                p["description"],
+                p.get("active_form", ""),
+                p.get("metadata"),
+            ),
+            read_only=False,
+            concurrent_safe=True,
+        ),
+        ToolDef(
+            name="TaskUpdate",
+            schema=_TASK_UPDATE_SCHEMA,
+            func=lambda p, c: _task_update(
+                p["task_id"],
+                subject=p.get("subject"),
+                description=p.get("description"),
+                status=p.get("status"),
+                active_form=p.get("active_form"),
+                owner=p.get("owner"),
+                add_blocks=p.get("add_blocks"),
+                add_blocked_by=p.get("add_blocked_by"),
+                metadata=p.get("metadata"),
+            ),
+            read_only=False,
+            concurrent_safe=True,
+        ),
+        ToolDef(
+            name="TaskGet",
+            schema=_TASK_GET_SCHEMA,
+            func=lambda p, c: _task_get(p["task_id"]),
+            read_only=True,
+            concurrent_safe=True,
+        ),
+        ToolDef(
+            name="TaskList",
+            schema=_TASK_LIST_SCHEMA,
+            func=lambda p, c: _task_list(),
+            read_only=True,
+            concurrent_safe=True,
+        ),
+    ]
+    for td in defs:
+        register_tool(td)
+
+
+_register()