bone-agent 0.1.0

package/defaults/lua/tools/cron.lua

@@ -0,0 +1,253 @@
+local PYTHON_SCRIPT = [=[
+import base64, json, os, re, shlex, subprocess, sys
+from pathlib import Path
+
+def env(name, default=""):
+    return os.environ.get(name, default)
+
+def bone_dir():
+    xdg = env("XDG_CONFIG_HOME")
+    if xdg: return Path(xdg) / "bone-rust"
+    home = env("HOME") or env("USERPROFILE")
+    if home: return Path(home) / ".bone-rust"
+    return Path(".bone-rust").resolve()
+
+def find_bone():
+    explicit = env("BONE_BIN")
+    if explicit and os.access(explicit, os.X_OK):
+        return str(Path(explicit).resolve())
+    for part in env("PATH").split(os.pathsep):
+        candidate = Path(part) / "bone"
+        if os.access(candidate, os.X_OK):
+            return str(candidate.resolve())
+    print("bone binary not found. Set BONE_BIN=/path/to/bone", file=sys.stderr)
+    sys.exit(127)
+
+def validate_name(name):
+    if not re.fullmatch(r"[A-Za-z0-9_-]+", name or ""):
+        fail("job name must contain only letters, numbers, '-' and '_'")
+
+def parse_time(value):
+    m = re.fullmatch(r"(\d{1,2}):(\d{2})", value or "")
+    if not m: fail("time must be HH:MM")
+    hour, minute = int(m.group(1)), int(m.group(2))
+    if hour > 23 or minute > 59: fail("time must be between 00:00 and 23:59")
+    return hour, minute
+
+def validate_approval(value):
+    if value not in ("read_only", "danger"):
+        fail("approval must be read_only or danger")
+    return value
+
+def fail(message, code=2):
+    print(message, file=sys.stderr)
+    sys.exit(code)
+
+def cron_missing():
+    fail("crontab not found. Install cronie or cron.", 127)
+
+def current_crontab():
+    try:
+        p = subprocess.run(["crontab", "-l"], text=True, capture_output=True)
+    except FileNotFoundError:
+        cron_missing()
+    if p.returncode == 0: return p.stdout
+    if "no crontab" in p.stderr.lower(): return ""
+    fail(p.stderr.strip() or f"crontab -l exited with {p.returncode}", p.returncode)
+
+def write_crontab(content):
+    try:
+        p = subprocess.run(["crontab", "-"], input=content, text=True, capture_output=True)
+    except FileNotFoundError:
+        cron_missing()
+    if p.returncode != 0:
+        fail(p.stderr.strip() or f"crontab exited with {p.returncode}", p.returncode)
+
+def encode_metadata(job):
+    raw = json.dumps(job, separators=(",", ":")).encode()
+    return base64.urlsafe_b64encode(raw).decode().rstrip("=")
+
+def decode_metadata(value):
+    try:
+        padded = value + "=" * ((4 - len(value) % 4) % 4)
+        return json.loads(base64.urlsafe_b64decode(padded.encode()))
+    except Exception:
+        return None
+
+def parse_cron_line(line):
+    marker = "# BONE:"
+    if marker not in line: return None
+    body, encoded = line.rsplit(marker, 1)
+    fields = body.split()
+    if len(fields) < 5 or fields[2:5] != ["*", "*", "*"]: return None
+    try:
+        minute, hour = int(fields[0]), int(fields[1])
+    except ValueError: return None
+    meta = decode_metadata(encoded.strip())
+    if not meta:
+        name = encoded.strip()
+        if not re.fullmatch(r"[A-Za-z0-9_-]+", name): return None
+        meta = {"name": name, "approval": "", "cwd": "", "prompt": "", "log_path": ""}
+    meta["minute"] = minute
+    meta["hour"] = hour
+    return meta
+
+def build_cron_line(job):
+    args = [job["bone_bin"], "run", "--approval", job["approval"]]
+    args.extend(["--prompt", job["prompt"]])
+    command = "cd " + shlex.quote(job["cwd"]) + " && " + " ".join(shlex.quote(a) for a in args)
+    command += " >> " + shlex.quote(job["log_path"]) + " 2>&1"
+    meta = {k: job[k] for k in ("name", "approval", "cwd", "prompt", "log_path")}
+    return f'{job["minute"]} {job["hour"]} * * * {command} # BONE:{encode_metadata(meta)}'
+
+def list_jobs():
+    jobs = [j for j in (parse_cron_line(line) for line in current_crontab().splitlines()) if j]
+    if not jobs:
+        print("No bone cron jobs.")
+        return
+    print("NAME\tTIME\tAPPROVAL\tCWD\tPROMPT")
+    for j in jobs:
+        print(f'{j.get("name", "")}\t{j["hour"]:02d}:{j["minute"]:02d}\t{j.get("approval", "")}\t{j.get("cwd", "")}\t{j.get("prompt", "")}')
+
+def add_job():
+    name, time, prompt = env("TOOL_NAME"), env("TOOL_TIME"), env("TOOL_PROMPT")
+    approval = validate_approval(env("TOOL_APPROVAL", "read_only") or "read_only")
+    if not name or not time or not prompt:
+        fail("Usage: cron add requires name, time, and prompt.")
+    validate_name(name)
+    hour, minute = parse_time(time)
+    cwd = str(Path(env("TOOL_CWD") or os.getcwd()).resolve())
+    log_dir = bone_dir() / "runs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    job = {"name": name, "hour": hour, "minute": minute, "approval": approval,
+           "cwd": cwd, "prompt": prompt, "log_path": str(log_dir / f"{name}.log"),
+           "bone_bin": find_bone()}
+    existing = current_crontab().splitlines()
+    kept = []
+    for line in existing:
+        parsed = parse_cron_line(line)
+        legacy_tag = line.rstrip().endswith(f"# BONE:{name}")
+        if (parsed and parsed.get("name") == name) or legacy_tag: continue
+        kept.append(line)
+    kept.append(build_cron_line(job))
+    write_crontab("\n".join(kept) + "\n")
+    print(f"Added cron job {name}.")
+
+def remove_job():
+    name = env("TOOL_NAME")
+    if not name: fail("Usage: cron remove requires name.")
+    validate_name(name)
+    removed = False
+    kept = []
+    for line in current_crontab().splitlines():
+        parsed = parse_cron_line(line)
+        legacy_tag = line.rstrip().endswith(f"# BONE:{name}")
+        if (parsed and parsed.get("name") == name) or legacy_tag: removed = True
+        else: kept.append(line)
+    write_crontab(("\n".join(kept) + "\n") if kept else "")
+    print(f"Removed cron job {name}." if removed else f"No cron job named {name}.")
+
+def show_logs():
+    name = env("TOOL_NAME")
+    if not name: fail("Usage: cron logs requires name.")
+    validate_name(name)
+    path = bone_dir() / "runs" / f"{name}.log"
+    try: lines = path.read_text().splitlines()
+    except OSError as e: fail(f"failed to read {path}: {e}", 1)
+    tail = env("TOOL_TAIL")
+    if tail:
+        try: n = int(tail)
+        except ValueError: fail("tail must be a number")
+        lines = lines[-n:]
+    print("\n".join(lines))
+
+def help_text():
+    print("""Manage Bone scheduled jobs.
+
+  Examples:
+    cron(action=list)
+    cron(action=add, name=daily-clean, time=09:00, approval=danger, prompt=/clean src/main.rs)
+    cron(action=remove, name=daily-clean)
+    cron(action=logs, name=daily-clean, tail=100)""")
+
+action = env("TOOL_ACTION")
+if action == "list": list_jobs()
+elif action == "add": add_job()
+elif action in ("remove", "rm"): remove_job()
+elif action == "logs": show_logs()
+elif action in ("help", "--help", "-h", ""): help_text()
+else: fail(f"Unknown cron action: {action}")
+]=]
+
+local function execute(params, ctx)
+    local action = params.action or ""
+    local name = params.name or ""
+    local time = params.time or ""
+    local approval = params.approval or "read_only"
+    local prompt = params.prompt or ""
+    local cwd = params.cwd or ""
+    local tail = params.tail or ""
+
+    -- Build export commands for TOOL_* variables
+    local exports = {}
+    table.insert(exports, 'export TOOL_ACTION="' .. action:gsub('"', '\\"') .. '"')
+    if name ~= "" then table.insert(exports, 'export TOOL_NAME="' .. name:gsub('"', '\\"') .. '"') end
+    if time ~= "" then table.insert(exports, 'export TOOL_TIME="' .. time:gsub('"', '\\"') .. '"') end
+    if approval ~= "" then table.insert(exports, 'export TOOL_APPROVAL="' .. approval:gsub('"', '\\"') .. '"') end
+    if prompt ~= "" then table.insert(exports, 'export TOOL_PROMPT="' .. prompt:gsub('"', '\\"') .. '"') end
+    if cwd ~= "" then table.insert(exports, 'export TOOL_CWD="' .. cwd:gsub('"', '\\"') .. '"') end
+    if tail ~= "" then table.insert(exports, 'export TOOL_TAIL="' .. tail:gsub('"', '\\"') .. '"') end
+
+    local cmd = table.concat(exports, "; ")
+    cmd = cmd .. "; uv run --no-project --no-sync -- python3 <<'PYEOF'\n"
+    cmd = cmd .. PYTHON_SCRIPT
+    cmd = cmd .. "\nPYEOF"
+
+    local result = ctx.shell(cmd, { timeout_ms = 300000 })
+    if result.stderr and #result.stderr > 0 then
+        return "ERROR: " .. result.stderr
+    end
+    return result.stdout or ""
+end
+
+bone.register_tool({
+    name = "cron",
+    description = "Manage Bone scheduled jobs for the user. Use this when the user asks to schedule, list, remove, or inspect recurring Bone tasks. Fully implemented as a custom tool; supports daily HH:MM schedules.",
+    parameters = {
+        type = "object",
+        properties = {
+            action = {
+                type = "string",
+                description = "Action: add, list, remove, logs, or help.",
+            },
+            name = {
+                type = "string",
+                description = "Job name for add/remove/logs. Use letters, numbers, '-' or '_'.",
+            },
+            time = {
+                type = "string",
+                description = "Daily run time in HH:MM 24-hour local time, required for add.",
+            },
+            approval = {
+                type = "string",
+                description = "Approval mode for add: read_only or danger. Defaults to read_only.",
+            },
+            prompt = {
+                type = "string",
+                description = "Prompt or command invocation for add.",
+            },
+            cwd = {
+                type = "string",
+                description = "Working directory for add. Defaults to current directory.",
+            },
+            tail = {
+                type = "number",
+                description = "Number of log lines for logs.",
+            },
+        },
+        required = { "action" },
+        additionalProperties = false,
+    },
+    safety = "danger",
+    execute = execute,
+})

package/defaults/lua/tools/subagent.lua

@@ -0,0 +1,350 @@
+-- Sub-agent tool: discovery, dispatch, and status reporting.
+--
+-- Only active when sub-agents are registered via bone.register_subagent in
+-- init.lua.  When no agents are registered, this file is a no-op (zero
+-- overhead) — the tool is never created.
+--
+-- The live status pane is rendered natively in Rust (src/ui/subagent_pane.rs)
+-- so it stays responsive even while this tool blocks the Lua VM.
+
+-- cjson is a global injected by Rust (encode/decode via serde_json)
+
+-- ---------------------------------------------------------------------------
+-- Early exits
+-- ---------------------------------------------------------------------------
+
+-- Sub-agents must not spawn nested sub-agents: never register the tool
+-- inside a sub-agent VM.
+if bone.agent_depth and bone.agent_depth > 0 then
+    return
+end
+
+local subagents = bone._subagents
+if not subagents or #subagents == 0 then
+    return
+end
+
+-- Headless mode (CLI): background job auto-injection is unavailable, so
+-- dispatch must always block for results.
+local headless = bone.headless and true or false
+
+-- ---------------------------------------------------------------------------
+-- Helpers
+-- ---------------------------------------------------------------------------
+
+--- Numeric part of a "job-N" id (0 when malformed).
+local function job_id_number(id)
+    return tonumber((id or ""):match("(%d+)$")) or 0
+end
+
+--- Build a human-readable status string for a single job.
+local function job_status(job)
+    if not job then
+        return "○ idle"
+    end
+
+    if job.status == "running" then
+        local elapsed = os.time() - job.started_at
+        local task = job.task or ""
+        if #task > 40 then
+            task = task:sub(1, 37) .. "..."
+        end
+        local sent = job.token_sent or 0
+        local received = job.token_received or 0
+        return string.format("◑ running %s (%ds) %s/%s in/out", task, elapsed, sent, received)
+    end
+    -- done → treat as idle
+    if job.status == "done" then
+        local sent = job.token_sent or 0
+        local received = job.token_received or 0
+        if sent > 0 or received > 0 then
+            return string.format("○ idle (%s/%s in/out)", sent, received)
+        end
+        return "○ idle"
+    end
+    -- error
+    return "✗ error"
+end
+
+--- Build a status summary string for one agent (latest job by id).
+local function agent_status(agent, jobs)
+    local latest = nil
+    for _, j in ipairs(jobs) do
+        if j.agent == agent.name then
+            if not latest or job_id_number(j.id) > job_id_number(latest.id) then
+                latest = j
+            end
+        end
+    end
+    return job_status(latest)
+end
+
+-- ---------------------------------------------------------------------------
+-- Build dynamic tool description
+-- ---------------------------------------------------------------------------
+
+local function build_description()
+    local parts = {
+        "Delegate tasks to registered sub-agents. Each agent runs in its own isolated context and only sees the task text you give it — write self-contained tasks (include file paths, goals, constraints, and the expected output format).",
+        "",
+        "Registered agents:",
+    }
+    for _, agent in ipairs(subagents) do
+        local extras = {}
+        if agent.approval then
+            extras[#extras + 1] = "approval: " .. agent.approval
+        end
+        local suffix = #extras > 0 and (" [" .. table.concat(extras, ", ") .. "]") or ""
+        parts[#parts + 1] = string.format("  - %s: %s%s", agent.name, agent.description, suffix)
+    end
+    parts[#parts + 1] = ""
+    if headless then
+        parts[#parts + 1] = table.concat({
+            "Actions:",
+            '- dispatch: start one or more tasks (one tasks[] entry each, run in parallel). Blocks until all dispatched tasks finish and returns their results.',
+            '- wait: block until previously dispatched jobs finish. Waits on the given ids[] (or all running jobs when omitted) and returns their results.',
+            '- status: non-blocking snapshot of job progress. Use sparingly; never call status in a loop.',
+            "",
+            "Rules:",
+            "- Batch independent tasks into a single dispatch call to maximize parallelism.",
+            "- Each agent runs one job at a time; dispatching to a busy agent is rejected.",
+        }, "\n")
+    else
+        parts[#parts + 1] = table.concat({
+            "Actions:",
+            '- dispatch: start one or more tasks (one tasks[] entry each, run in parallel).',
+            '  - If you need the results to continue, or you have nothing else productive to do, set wait=true: the call blocks and returns the results directly. This is the right choice for fan-out/fan-in work (e.g. dispatching research and then synthesizing it).',
+            '  - Omit wait ONLY when you have separate, independent work to do that does NOT overlap the dispatched tasks: dispatch returns immediately and you continue on that other work. Finished results are delivered automatically in a later message — do NOT poll for them, and NEVER fabricate or assume results you have not received.',
+            '- wait: block until previously dispatched jobs finish. Waits on the given ids[] (or all running jobs when omitted) and returns their results. Use when you reach a point where you need pending results before continuing.',
+            '- status: non-blocking snapshot of job progress. Use sparingly; never call status in a loop.',
+            "",
+            "Rules:",
+            "- Batch independent tasks into a single dispatch call to maximize parallelism.",
+            "- Each agent runs one job at a time; dispatching to a busy agent is rejected.",
+            "- NEVER duplicate the work you delegated. Once a task is dispatched, do not read the same files, run the same searches, or research the same questions yourself — that wastes context and defeats the purpose of delegating. Let the sub-agent do it.",
+            "- After a non-waiting dispatch, do only your separate independent work, then end your turn; the results arrive as an automated message. If you have no such independent work, you should have used wait=true instead.",
+        }, "\n")
+    end
+    return table.concat(parts, "\n")
+end
+
+-- ---------------------------------------------------------------------------
+-- Result formatting helpers
+-- ---------------------------------------------------------------------------
+
+-- Per-job character budget for results returned by wait (mirrors the Rust
+-- auto-injection limit).
+local MAX_RESULT_CHARS = 16000
+
+--- Truncate to a byte budget without splitting a UTF-8 sequence.
+local function truncate_result(s, max)
+    if #s <= max then
+        return s
+    end
+    local cut = max
+    while cut > 0 do
+        local b = s:byte(cut + 1)
+        if not b or b < 0x80 or b >= 0xC0 then
+            break
+        end
+        cut = cut - 1
+    end
+    return s:sub(1, cut) .. "\n[... truncated]"
+end
+
+--- Format a ctx.agent.wait outcome into a report for the model.
+local function format_wait_outcome(outcome)
+    local parts = {}
+    for _, job in ipairs(outcome.jobs or {}) do
+        local sym = job.status == "done" and "done" or "ERROR"
+        local body = truncate_result(job.result or "", MAX_RESULT_CHARS)
+        if job.result_file then
+            body = body .. string.format("\n[full output saved to: %s]", job.result_file)
+        end
+        parts[#parts + 1] = string.format(
+            "## %s (%s) — %s\n%s",
+            job.agent ~= "" and job.agent or "agent",
+            job.id,
+            sym,
+            body
+        )
+    end
+    if outcome.cancelled then
+        parts[#parts + 1] = "Wait cancelled by user; jobs keep running and their results will arrive automatically."
+    elseif outcome.timed_out then
+        parts[#parts + 1] = string.format(
+            "Wait timed out with jobs still running: %s. Their results will arrive automatically in a later message — do not assume their outcome.",
+            table.concat(outcome.pending or {}, ", ")
+        )
+    end
+    if #parts == 0 then
+        parts[#parts + 1] = "No jobs to wait on."
+    end
+    return table.concat(parts, "\n\n")
+end
+
+-- ---------------------------------------------------------------------------
+-- Tool execute function
+-- ---------------------------------------------------------------------------
+
+local function execute(params, ctx)
+    local action = params.action or ""
+
+    if action == "dispatch" then
+        local tasks = params.tasks or {}
+        if #tasks == 0 then
+            return "ERROR: Provide tasks for 'dispatch'."
+        end
+
+        local results = {}
+        local dispatched_ids = {}
+        local ok_count = 0
+        local err_count = 0
+
+        for _, t in ipairs(tasks) do
+            local agent_name = t.agent or ""
+            local task_desc = t.task or ""
+
+            -- Look up the agent definition
+            local agent_def = nil
+            for _, a in ipairs(subagents) do
+                if a.name == agent_name then
+                    agent_def = a
+                    break
+                end
+            end
+
+            if agent_def then
+                -- Build spawn opts from the agent definition.
+                -- Busy agents are rejected atomically by the Rust registry.
+                local opts = {
+                    agent = agent_name,
+                    system_prompt = agent_def.system_prompt,
+                    provider = agent_def.provider,
+                    model = agent_def.model,
+                    approval = agent_def.approval,
+                    timeout_ms = agent_def.timeout_ms,
+                }
+
+                local result = ctx.agent.spawn(task_desc, opts)
+                if result.ok then
+                    results[#results + 1] = string.format(
+                        "dispatched %s → %s", result.id, agent_name
+                    )
+                    dispatched_ids[#dispatched_ids + 1] = result.id
+                    ok_count = ok_count + 1
+                else
+                    results[#results + 1] = string.format(
+                        "REJECTED: %s — %s", agent_name, result.error or "unknown"
+                    )
+                    err_count = err_count + 1
+                end
+            else
+                results[#results + 1] = string.format(
+                    "REJECTED: unknown agent '%s'", agent_name
+                )
+                err_count = err_count + 1
+            end
+        end
+
+        local summary = string.format(
+            "Dispatched %d, rejected %d", ok_count, err_count
+        )
+        if err_count > 0 then
+            summary = summary .. "\n" .. table.concat(results, "\n")
+        end
+
+        -- Blocking dispatch: wait for the dispatched jobs and return results.
+        -- Headless mode always blocks (no background auto-injection there).
+        local should_wait = params.wait or headless
+        if should_wait and #dispatched_ids > 0 then
+            local outcome = ctx.agent.wait(dispatched_ids, { timeout_ms = params.timeout_ms })
+            if outcome.ok then
+                summary = summary .. "\n\n" .. format_wait_outcome(outcome)
+            else
+                summary = summary .. "\n\nERROR waiting: " .. (outcome.error or "unknown")
+            end
+        end
+
+        return summary
+    end
+
+    if action == "wait" then
+        local outcome = ctx.agent.wait(params.ids, { timeout_ms = params.timeout_ms })
+        if not outcome.ok then
+            return "ERROR: " .. (outcome.error or "unknown")
+        end
+        return format_wait_outcome(outcome)
+    end
+
+    if action == "status" then
+        local jobs = ctx.agent.jobs()
+        local parts = { "Sub-agent status:" }
+        for _, agent in ipairs(subagents) do
+            parts[#parts + 1] = string.format("  %s: %s", agent.name, agent_status(agent, jobs))
+        end
+        return table.concat(parts, "\n")
+    end
+
+    return "ERROR: Action must be 'dispatch', 'wait' or 'status'."
+end
+
+-- ---------------------------------------------------------------------------
+-- Register the tool
+-- ---------------------------------------------------------------------------
+
+bone.register_tool({
+    name = "subagent",
+    description = build_description(),
+    safety = "read_only",
+    parameters = {
+        type = "object",
+        properties = {
+            action = {
+                type = "string",
+                enum = { "dispatch", "wait", "status" },
+                description = "dispatch (start tasks), wait (block for results), or status (non-blocking snapshot)",
+            },
+            tasks = {
+                type = "array",
+                description = "dispatch only: list of tasks to start in parallel. Each item: {agent: string, task: string}",
+                items = {
+                    type = "object",
+                    properties = {
+                        agent = {
+                            type = "string",
+                            description = "Registered agent name",
+                        },
+                        task = {
+                            type = "string",
+                            description = "Self-contained task description for the agent (it sees nothing else)",
+                        },
+                    },
+                    required = { "agent", "task" },
+                    additionalProperties = false,
+                },
+            },
+            wait = {
+                type = "boolean",
+                description = "dispatch only: block until the dispatched tasks finish and return their results. Use when your next step depends on them.",
+            },
+            ids = {
+                type = "array",
+                items = { type = "string" },
+                description = "wait only: job ids to wait for (omit to wait for all running jobs)",
+            },
+            timeout_ms = {
+                type = "integer",
+                description = "dispatch(wait=true)/wait: max time to block in milliseconds (default 300000)",
+            },
+        },
+        required = { "action" },
+        additionalProperties = false,
+    },
+    display = {
+        show = true,
+        show_result = false,
+        args = { "action", "tasks", "wait", "ids" },
+    },
+    execute = execute,
+})