bone-agent 0.1.0

package/defaults/lua/commands/memory.lua

@@ -0,0 +1,164 @@
+bone.register_command("memory", {
+  description = "Incremental memory builder. Processes all conversations since last run and updates memory.md.",
+  handler = function(args, ctx)
+    local bone_dir = ctx.config_dir
+    local db = bone_dir .. "/data/conversations.db"
+    local state_file = bone_dir .. "/memory.last_run"
+
+    -- Check if database exists
+    if not ctx.fs.is_file(db) then
+      return [=[You are a memory builder running in "dream" mode — processing conversations that happened since your last run.
+
+## Context
+No conversation database found. Nothing to process.
+
+## Your task
+1. Read the current memory.md from the bone config directory. If it doesn't exist, start fresh.
+2. Review each conversation above for user preferences, patterns, and context.
+3. Write an updated memory.md using write_file or edit_file.
+4. After updating memory.md (or deciding no changes are needed), write the value of NEXT_RUN (shown above) to `$HOME/.bone-rust/memory.last_run`. This advances the checkpoint so processed conversations aren't re-processed. Only do this last.
+
+## Rules
+- Only add preferences clearly demonstrated (seen 2+ times across conversations), not one-off remarks.
+- Remove anything contradicted by newer conversations.
+- Keep the file under 400 tokens. Merge, compress, and drop lower-priority items to fit. Prefer short bullet points over prose. When the file exceeds this limit, consolidate by merging similar items and dropping the least important entries until it fits.
+- Start the file with a metadata line: <!-- last_updated: YYYY-MM-DD -->
+- Use these markdown sections (drop empty ones, add relevant ones):
+  - Communication — how the user likes to communicate, verbosity preferences, response format preferences
+  - Coding Style — language preferences, patterns, naming conventions, architecture tastes
+  - Tools & Workflow — preferred tools, workflows, development habits
+  - Dislikes — things the user consistently avoids or objects to
+- Do NOT include project-specific context, task details, or one-off requirements. This file captures general preferences and habits, not what the user is working on right now.
+- If no meaningful changes are needed, leave memory.md as-is and say "No changes."
+- Output a brief summary of what you added, changed, or removed (or "No changes.").]=]
+    end
+
+    -- Read last run timestamp or default to epoch
+    local since = "1970-01-01T00:00:00Z"
+    if ctx.fs.is_file(state_file) then
+      local ok, state_content = pcall(ctx.read_file, state_file)
+      if ok and state_content then
+        since = state_content:gsub("%s+", "")
+      end
+    end
+
+    -- Get conversation IDs since last run
+    local cids_query = string.format(
+      "SELECT id FROM conversations WHERE started_at > '%s' ORDER BY started_at ASC;",
+      since
+    )
+    local cids_result = ctx.shell("sqlite3 " .. db .. " '" .. cids_query .. "'")
+    if cids_result.exit_code ~= 0 then
+      return [=[You are a memory builder running in "dream" mode — processing conversations that happened since your last run.
+
+## Context
+Error querying conversations: ]=] .. cids_result.stderr .. [=[
+
+## Your task
+1. Read the current memory.md from the bone config directory. If it doesn't exist, start fresh.
+2. Review each conversation above for user preferences, patterns, and context.
+3. Write an updated memory.md using write_file or edit_file.
+4. After updating memory.md (or deciding no changes are needed), write the value of NEXT_RUN (shown above) to `$HOME/.bone-rust/memory.last_run`. This advances the checkpoint so processed conversations aren't re-processed. Only do this last.
+
+## Rules
+- Only add preferences clearly demonstrated (seen 2+ times across conversations), not one-off remarks.
+- Remove anything contradicted by newer conversations.
+- Keep the file under 400 tokens. Merge, compress, and drop lower-priority items to fit. Prefer short bullet points over prose. When the file exceeds this limit, consolidate by merging similar items and dropping the least important entries until it fits.
+- Start the file with a metadata line: <!-- last_updated: YYYY-MM-DD -->
+- Use these markdown sections (drop empty ones, add relevant ones):
+  - Communication — how the user likes to communicate, verbosity preferences, response format preferences
+  - Coding Style — language preferences, patterns, naming conventions, architecture tastes
+  - Tools & Workflow — preferred tools, workflows, development habits
+  - Dislikes — things the user consistently avoids or objects to
+- Do NOT include project-specific context, task details, or one-off requirements. This file captures general preferences and habits, not what the user is working on right now.
+- If no meaningful changes are needed, leave memory.md as-is and say "No changes."
+- Output a brief summary of what you added, changed, or removed (or "No changes.").]=]
+    end
+
+    local cids = cids_result.stdout:match("^%s*(.-)%s*$")
+    if cids == "" then
+      return [=[You are a memory builder running in "dream" mode — processing conversations that happened since your last run.
+
+## Context
+No new conversations since ]=] .. since .. [=[:.
+
+## Your task
+1. Read the current memory.md from the bone config directory. If it doesn't exist, start fresh.
+2. Review each conversation above for user preferences, patterns, and context.
+3. Write an updated memory.md using write_file or edit_file.
+4. After updating memory.md (or deciding no changes are needed), write the value of NEXT_RUN (shown above) to `$HOME/.bone-rust/memory.last_run`. This advances the checkpoint so processed conversations aren't re-processed. Only do this last.
+
+## Rules
+- Only add preferences clearly demonstrated (seen 2+ times across conversations), not one-off remarks.
+- Remove anything contradicted by newer conversations.
+- Keep the file under 400 tokens. Merge, compress, and drop lower-priority items to fit. Prefer short bullet points over prose. When the file exceeds this limit, consolidate by merging similar items and dropping the least important entries until it fits.
+- Start the file with a metadata line: <!-- last_updated: YYYY-MM-DD -->
+- Use these markdown sections (drop empty ones, add relevant ones):
+  - Communication — how the user likes to communicate, verbosity preferences, response format preferences
+  - Coding Style — language preferences, patterns, naming conventions, architecture tastes
+  - Tools & Workflow — preferred tools, workflows, development habits
+  - Dislikes — things the user consistently avoids or objects to
+- Do NOT include project-specific context, task details, or one-off requirements. This file captures general preferences and habits, not what the user is working on right now.
+- If no meaningful changes are needed, leave memory.md as-is and say "No changes."
+- Output a brief summary of what you added, changed, or removed (or "No changes.").]=]
+    end
+
+    -- Count conversations
+    local count = 0
+    for _ in cids:gmatch("[^\n]+") do
+      count = count + 1
+    end
+
+    -- Get next run timestamp
+    local now_result = ctx.shell("date -u +\"%Y-%m-%dT%H:%M:%SZ\"")
+    local next_run = now_result.stdout:match("^%s*(.-)%s*$")
+    if next_run == "" then
+      next_run = "unknown"
+    end
+
+    -- Build conversation blocks
+    local conv_blocks = ""
+    for cid in cids:gmatch("[^\n]+") do
+      cid = cid:match("^%s*(.-)%s*$")
+      local msg_query = string.format(
+        "SELECT '[' || m.role || '] ' || m.content FROM messages WHERE m.conversation_id = %s AND m.role IN ('user', 'assistant') AND m.tool_name IS NULL ORDER BY m.seq ASC;",
+        cid
+      )
+      local msg_result = ctx.shell("sqlite3 " .. db .. " '" .. msg_query .. "'")
+      local block = "## Conversation " .. cid .. "\n"
+      if msg_result.exit_code == 0 then
+        block = block .. msg_result.stdout
+      else
+        block = block .. "(failed to read conversation " .. cid .. ")"
+      end
+      block = block .. "\n"
+      conv_blocks = conv_blocks .. block
+    end
+
+    return [=[You are a memory builder running in "dream" mode — processing conversations that happened since your last run.
+
+## Context
+Conversations since ]=] .. since .. ": " .. count .. [=[
+---
+NEXT_RUN=]=] .. next_run .. conv_blocks .. [=[
+## Your task
+1. Read the current memory.md from the bone config directory. If it doesn't exist, start fresh.
+2. Review each conversation above for user preferences, patterns, and context.
+3. Write an updated memory.md using write_file or edit_file.
+4. After updating memory.md (or deciding no changes are needed), write the value of NEXT_RUN (shown above) to `$HOME/.bone-rust/memory.last_run`. This advances the checkpoint so processed conversations aren't re-processed. Only do this last.
+
+## Rules
+- Only add preferences clearly demonstrated (seen 2+ times across conversations), not one-off remarks.
+- Remove anything contradicted by newer conversations.
+- Keep the file under 400 tokens. Merge, compress, and drop lower-priority items to fit. Prefer short bullet points over prose. When the file exceeds this limit, consolidate by merging similar items and dropping the least important entries until it fits.
+- Start the file with a metadata line: <!-- last_updated: YYYY-MM-DD -->
+- Use these markdown sections (drop empty ones, add relevant ones):
+  - Communication — how the user likes to communicate, verbosity preferences, response format preferences
+  - Coding Style — language preferences, patterns, naming conventions, architecture tastes
+  - Tools & Workflow — preferred tools, workflows, development habits
+  - Dislikes — things the user consistently avoids or objects to
+- Do NOT include project-specific context, task details, or one-off requirements. This file captures general preferences and habits, not what the user is working on right now.
+- If no meaningful changes are needed, leave memory.md as-is and say "No changes."
+- Output a brief summary of what you added, changed, or removed (or "No changes.").]=]
+  end,
+})

package/defaults/lua/commands/review.lua

@@ -0,0 +1,31 @@
+-- /review — review unstaged changes for code smells, bugs, logic errors,
+-- dead code, and clean code.
+--
+-- Requires: ctx.shell("git diff --no-color"), submit=true to trigger LLM.
+
+bone.register_command("review", {
+  description = "Review unstaged changes for bugs, smells, dead code, and clean code",
+  handler = function(_, ctx)
+    local result = ctx.shell("git diff --no-color")
+    if result.exit_code ~= 0 or (result.stdout:gsub("^%s*", "") == "") then
+      return { display = "No unstaged changes to review.", submit = false }
+    end
+
+    local diff = result.stdout
+    -- Truncate very large diffs to avoid blowing the prompt
+    if #diff > 50000 then
+      diff = diff:sub(1, 50000) .. "\n... (truncated, diff exceeds 50k chars)"
+    end
+
+    local prompt = [[Review these unstaged changes for code smells, bugs, logic errors, dead code, and clean code:
+- Point out any bugs or potential bugs (null dereferences, off-by-one, resource leaks, etc.)
+- Identify code smells (long functions, deep nesting, duplicated logic, God classes, etc.)
+- Flag dead or unreachable code
+- Suggest specific improvements for readability and maintainability
+- Note any security concerns
+
+Be thorough but organized. Group findings by file, and quote relevant code snippets.]]
+
+    return { display = prompt .. "\n\n" .. diff, submit = true }
+  end,
+})

package/defaults/lua/commands/usage.lua

@@ -0,0 +1,118 @@
+local function comma(n)
+  n = math.floor(tonumber(n) or 0)
+  local s = tostring(n)
+  local sign = ""
+  if s:sub(1, 1) == "-" then
+    sign = "-"
+    s = s:sub(2)
+  end
+  local out = s
+  while true do
+    local next_out, changed = out:gsub("^(-?%d+)(%d%d%d)", "%1,%2")
+    out = next_out
+    if changed == 0 then break end
+  end
+  return sign .. out
+end
+
+local function tokens(n)
+  return comma(n)
+end
+
+local function money(n)
+  n = tonumber(n) or 0
+  if n <= 0 then return nil end
+  return string.format("$%.4f", n)
+end
+
+local DIM   = "\x1b[2m"
+local CYAN  = "\x1b[36m"
+local WHITE = "\x1b[37m"
+local RESET = "\x1b[0m"
+
+local function header(title)
+  return string.format("%s%s%s", CYAN, title, RESET)
+end
+
+local function section(title)
+  return string.format("%s%s%s", CYAN, title, RESET)
+end
+
+local function klabel(label)
+  return string.format("%s%-12s%s", DIM, label .. ":", RESET)
+end
+
+local function kvalue(v)
+  return string.format("%s%s%s", WHITE, v, RESET)
+end
+
+local function kdim(v)
+  return string.format("%s%s%s", DIM, v, RESET)
+end
+
+local function sep()
+  return string.format("%s%s%s", DIM, string.rep("─", 52), RESET)
+end
+
+bone.register_command("usage", {
+  description = "Show token usage for current conversation",
+  handler = function(_, ctx)
+    local usage = ctx.usage and ctx.usage.snapshot and ctx.usage.snapshot() or nil
+    if not usage then
+      return { display = "Usage data is unavailable in this context.", submit = false }
+    end
+
+    local total = (usage.sent or 0) + (usage.received or 0)
+    local lines = {
+      header("Conversation usage"),
+      sep(),
+      klabel("Requests") .. kvalue(comma(usage.request_count)),
+      klabel("Tokens")   .. kvalue(tokens(total) .. " total"),
+      klabel("Input")    .. kvalue(tokens(usage.sent)),
+      klabel("Output")   .. kvalue(tokens(usage.received)),
+      klabel("Context")  .. kvalue(tokens(usage.context_length) .. " current"),
+    }
+
+    if (usage.cached or 0) > 0 then
+      table.insert(lines, klabel("Cached") .. kvalue(tokens(usage.cached)))
+    end
+    local cost = money(usage.cost)
+    if cost then
+      table.insert(lines, klabel("Cost") .. kvalue(cost))
+    end
+    if (usage.request_count or 0) > 0 then
+      table.insert(lines, klabel("Avg/req") .. kvalue(tokens((usage.sent or 0) / usage.request_count) .. " in / " .. tokens((usage.received or 0) / usage.request_count) .. " out"))
+    end
+
+    table.insert(lines, "")
+    table.insert(lines, section("Prompt overhead"))
+    table.insert(lines, sep())
+    table.insert(lines, klabel("Tools") .. kvalue(comma(usage.tool_count) .. " tools, ~" .. tokens(usage.tool_schema_tokens) .. " tokens (" .. kdim(comma(usage.tool_schema_chars) .. " chars)") .. ")"))
+    table.insert(lines, klabel("System") .. kvalue("~" .. tokens(usage.system_prompt_tokens) .. " tokens (" .. kdim(comma(usage.system_prompt_chars) .. " chars)") .. ")"))
+
+    if usage.by_provider and #usage.by_provider > 1 then
+      table.insert(lines, "")
+      table.insert(lines, section("By provider/model"))
+      table.insert(lines, sep())
+      for _, p in ipairs(usage.by_provider) do
+        local row = string.format(
+          "  %s / %s — %s in / %s out",
+          kdim(p.provider or "unknown"),
+          kvalue(p.model or "unknown"),
+          tokens(p.prompt_tokens),
+          tokens(p.completion_tokens)
+        )
+        if (p.cached_tokens or 0) > 0 then
+          row = row .. " / " .. tokens(p.cached_tokens) .. " cached"
+        end
+        local provider_cost = money(p.cost)
+        if provider_cost then
+          row = row .. " / " .. kvalue(provider_cost)
+        end
+        table.insert(lines, row)
+      end
+    end
+
+    return { display = table.concat(lines, "\n"), submit = false }
+  end,
+})

package/defaults/lua/tools/ask_user.lua

@@ -0,0 +1,306 @@
+-- ask_user — interactive question tool using ctx.ui.interact()
+--
+-- Supports single_select, multi_select, and text_input question types.
+-- Questions are rendered in the bottom pane with keyboard-driven
+-- selection and optional custom text input.
+--
+-- Two calling modes:
+--   1. Single question: { question, options, allow_custom, type, default }
+--   2. Multi-question:  { questions = { {question, options, allow_custom, type, default}, ... } }
+--      Asks each question sequentially with backtracking navigation.
+--      After answering, user can go back to previous questions or proceed.
+
+local function format_answer(result)
+    if result.values then
+        local parts = {}
+        for _, v in ipairs(result.values) do
+            table.insert(parts, "  - " .. v)
+        end
+        if result.custom and result.custom ~= "" then
+            table.insert(parts, "  Custom: " .. result.custom)
+        end
+        return table.concat(parts, "\n")
+    elseif result.value then
+        if result.custom then
+            return "Custom answer: " .. result.value
+        else
+            return result.value
+        end
+    end
+    return "(no response)"
+end
+
+local function get_qtype(q)
+    local qtype = q.type
+    if not qtype then
+        local options = q.options or {}
+        local allow_custom = q.allow_custom or false
+        if #options > 0 then
+            if allow_custom or #options > 5 then
+                qtype = "multi_select"
+            else
+                qtype = "single_select"
+            end
+        else
+            qtype = "text_input"
+        end
+    end
+    return qtype
+end
+
+-- Flatten object-form options ({label, description}) to plain strings.
+-- ctx.ui.interact only accepts Vec<String>; rich entries are reduced to
+-- their label so the model still sees the original text as the answer.
+local function flatten_options(options)
+    local flat = {}
+    for i, opt in ipairs(options) do
+        if type(opt) == "table" then
+            flat[i] = opt.label or tostring(opt)
+        else
+            flat[i] = opt
+        end
+    end
+    return flat
+end
+
+local function ask_one(q, ctx)
+    local question = q.question
+    local options = flatten_options(q.options or {})
+    local allow_custom = q.allow_custom or false
+    local qtype = get_qtype(q)
+
+    local ok, result = pcall(ctx.ui.interact, {
+        question = question,
+        type = qtype,
+        options = options,
+        default = q.default,
+        allow_custom = allow_custom,
+    })
+
+    if not ok then
+        return nil, "interact failed: " .. tostring(result)
+    end
+
+    if result.cancelled then
+        return nil, "cancelled"
+    end
+
+    return format_answer(result)
+end
+
+-- Build navigation options after answering a question in multi-question mode
+-- Returns: list of option strings for the nav interact call
+local function build_nav_options(questions, answers, current_idx)
+    local opts = {}
+
+    -- Show summary of answered questions as pickable options to revise
+    for i = 1, #questions do
+        local short_q = questions[i].question
+        if #short_q > 50 then
+            short_q = short_q:sub(1, 47) .. "..."
+        end
+        if answers[i] then
+            local short_a = answers[i]
+            if #short_a > 40 then
+                short_a = short_a:sub(1, 37) .. "..."
+            end
+            table.insert(opts, string.format("Q%d: %s → %s", i, short_q, short_a))
+        else
+            table.insert(opts, string.format("Q%d: %s (unanswered)", i, short_q))
+        end
+    end
+
+    table.insert(opts, "✓ Submit all answers")
+
+    return opts
+end
+
+-- Parse what the user picked from navigation
+-- Returns: "submit", or a number (question index to jump to)
+local function parse_nav_choice(result, num_questions)
+    if result.custom then
+        local val = tonumber(result.value)
+        if val and val >= 1 and val <= num_questions then
+            return val
+        end
+        return "submit" -- fallback
+    end
+
+    local selected = result.value
+    if not selected then return "submit" end
+
+    if selected == "✓ Submit all answers" then
+        return "submit"
+    end
+
+    -- Extract question number from "Q%d: ..."
+    local qnum = selected:match("^Q(%d+):")
+    if qnum then
+        return tonumber(qnum)
+    end
+
+    return "submit"
+end
+
+local function ask_multi_with_backtrack(questions, ctx)
+    local answers = {}
+    local total = #questions
+
+    -- Fill answers table with nils
+    for _ = 1, total do table.insert(answers, nil) end
+
+    -- Start from first unanswered question
+    local function find_first_unanswered(start)
+        for i = start, total do
+            if not answers[i] then return i end
+        end
+        return nil
+    end
+
+    -- Main loop: ask questions, then show nav, repeat until submit
+    local ask_from = 1
+    while true do
+        -- Ask all unanswered questions from ask_from forward
+        local idx = find_first_unanswered(ask_from)
+        while idx do
+            local answer, err = ask_one(questions[idx], ctx)
+            if err == "cancelled" then
+                -- Treat cancellation as skip (nil answer)
+                answers[idx] = nil
+            elseif err then
+                answers[idx] = "error: " .. err
+            else
+                answers[idx] = answer
+            end
+            idx = find_first_unanswered(idx + 1)
+        end
+
+        -- Show navigation pane with summary
+        local nav_opts = build_nav_options(questions, answers, nil)
+        local ok, result = pcall(ctx.ui.interact, {
+            question = "Review your answers. Pick a question to revise, or submit.",
+            type = "single_select",
+            options = nav_opts,
+            allow_custom = false,
+        })
+
+        if not ok or (result and result.cancelled) then
+            -- Submit on cancel/escape
+            break
+        end
+
+        local choice = parse_nav_choice(result, total)
+        if choice == "submit" then
+            break
+        else
+            -- Jump back to revise that question
+            answers[choice] = nil
+            ask_from = choice
+        end
+    end
+
+    return answers
+end
+
+local function execute(params, ctx)
+    if not params.question and not (params.questions and #params.questions > 0) then
+        return "error: provide either 'question' or 'questions' parameter"
+    end
+
+    -- Multi-question mode
+    if params.questions and #params.questions > 0 then
+        local answers = ask_multi_with_backtrack(params.questions, ctx)
+
+        local parts = {}
+        for i, answer in ipairs(answers) do
+            if answer then
+                table.insert(parts, "Q" .. i .. ": " .. answer)
+            else
+                table.insert(parts, "Q" .. i .. ": [skipped]")
+            end
+        end
+
+        local result = table.concat(parts, "\n")
+        -- Clear pane after all questions are done
+        pcall(ctx.ui.pane, { source = "interact", title = "", lines = {} })
+        ctx.ui.notify(result, "info")
+        return result
+    end
+
+    -- Single-question mode (backward compat)
+    local answer, err = ask_one(params, ctx)
+    -- Clear pane after the question is answered
+    pcall(ctx.ui.pane, { source = "interact", title = "", lines = {} })
+    if err == "cancelled" then
+        return "[user cancelled]"
+    elseif err then
+        return err
+    end
+
+    local display = answer
+    if answer:sub(1, 1) == " " then
+        display = "Selected:\n" .. answer
+    end
+    ctx.ui.notify(display, "info")
+    return display
+end
+
+bone.register_tool({
+    name = "ask_user",
+    description = "Ask the user one or more questions with selectable options or custom answers. Use the 'questions' array to ask several questions back-to-back in a single call, or use top-level 'question' + 'options' for a single question.",
+    parameters = {
+        type = "object",
+        properties = {
+            question = {
+                type = "string",
+                description = "The question to ask (single-question mode).",
+            },
+            options = {
+                type = "array",
+                description = "List of options for the user to choose from (single-question mode).",
+                items = { type = "string" },
+            },
+            allow_custom = {
+                type = "boolean",
+                description = "Whether the user can type their own answer (single-question mode).",
+            },
+            questions = {
+                type = "array",
+                description = "Multiple questions to ask sequentially with backtracking. After answering all, you can revise any question. Each item is an object with {question, options, allow_custom, type, default}.",
+                items = {
+                    type = "object",
+                    properties = {
+                        question = { type = "string", description = "The question to ask." },
+                        options = {
+                            type = "array",
+                            items = { type = "string" },
+                            description = "List of options to choose from.",
+                        },
+                        allow_custom = {
+                            type = "boolean",
+                            description = "Whether the user can type their own answer.",
+                        },
+                        type = {
+                            type = "string",
+                            enum = { "single_select", "multi_select", "text_input" },
+                            description = "Question type. Auto-detected if omitted.",
+                        },
+                        default = {
+                            type = "number",
+                            description = "Default selected option index (1-based).",
+                        },
+                    },
+                    required = { "question" },
+                    additionalProperties = false,
+                },
+            },
+        },
+        additionalProperties = false,
+    },
+    safety = "read_only",
+    display = {
+        show = false,
+        args = { "question", "questions" },
+    },
+    execute = execute,
+})