@kkelly-offical/kkcode 0.1.2

package/src/tool/task-tool.mjs

@@ -0,0 +1,28 @@
+export function createTaskTool() {
+  return {
+    name: "task",
+    description: "Delegate complex multi-step work to a subagent that makes its own LLM calls. IMPORTANT: Do NOT use this for simple file operations — use 'write' to create files and 'edit' to modify files directly. Only use 'task' when the work requires multiple tool calls, reasoning, or autonomous decision-making (e.g. 'refactor module X', 'write tests for Y'). Background tasks (run_in_background) spawn a separate worker process.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        prompt: { type: "string", description: "task prompt" },
+        description: { type: "string", description: "short task description" },
+        subagent_type: { type: "string", description: "explicit subagent type" },
+        category: { type: "string", description: "routing category" },
+        run_in_background: { type: "boolean", description: "run async in background" },
+        session_id: { type: "string", description: "continue from existing sub session" },
+        stage_id: { type: "string", description: "optional stage id for orchestration" },
+        task_id: { type: "string", description: "optional logical task id" },
+        planned_files: { type: "array", items: { type: "string" }, description: "planned files for this task" },
+        allow_question: { type: "boolean", description: "allow question tool during delegated run" }
+      },
+      required: []
+    },
+    async execute(args, ctx) {
+      if (typeof ctx.delegateTask !== "function") {
+        return { error: "task delegate unavailable" }
+      }
+      return ctx.delegateTask(args || {})
+    }
+  }
+}

package/src/ui/activity-renderer.mjs

@@ -0,0 +1,410 @@
+import { EventBus } from "../core/events.mjs"
+import { EVENT_TYPES } from "../core/constants.mjs"
+import { paint } from "../theme/color.mjs"
+
+let _theme = null
+function diffAdd() { return _theme?.components?.diff_add || "green" }
+function diffDel() { return _theme?.components?.diff_del || "red" }
+
+// ── Symbols ──────────────────────────────────────────────
+export const SYM = {
+  dot: "●",
+  dotHollow: "○",
+  toolOk: "✓",
+  toolErr: "✗",
+  stage: "◆",
+  iteration: "↻",
+  phase: "●",
+  plan: "☐",
+  planDone: "☑",
+  recovery: "⟳",
+  alert: "!",
+  thinking: "▶",
+  thinkingOpen: "▼",
+  search: "*",
+  arrow: "→",
+  write: "◇"
+}
+
+// ── Helpers ──────────────────────────────────────────────
+
+function clipText(text, max) {
+  const s = String(text || "").trim()
+  if (s.length <= max) return s
+  return s.slice(0, max - 3) + "..."
+}
+
+function shortPath(p) {
+  const s = String(p || "").trim()
+  // Show last 2-3 segments for readability
+  const parts = s.replace(/\\/g, "/").split("/")
+  if (parts.length <= 3) return s
+  return ".../" + parts.slice(-3).join("/")
+}
+
+// ── Tool Display Formatters ──────────────────────────────
+
+export function formatToolStart(toolName, args) {
+  // Compact single-line dim format (OpenCode style)
+  const sym = toolName === "grep" || toolName === "glob" || toolName === "websearch"
+    ? SYM.search
+    : toolName === "write" || toolName === "edit" || toolName === "notebookedit"
+      ? SYM.write
+      : SYM.arrow
+  const prefix = paint(sym, "#666666")
+  const name = paint(toolName.charAt(0).toUpperCase() + toolName.slice(1), null, { dim: true })
+
+  switch (toolName) {
+    case "bash": {
+      const desc = clipText(args?.description || args?.command, 80)
+      return `  ${prefix} ${name} ${paint(desc, null, { dim: true })}`
+    }
+    case "write":
+    case "edit":
+      return `  ${prefix} ${name} ${paint(shortPath(args?.path), null, { dim: true })}`
+    case "notebookedit":
+      return `  ${prefix} ${name} ${paint(shortPath(args?.path), null, { dim: true })} ${paint(`cell ${args?.cell_number ?? 0}`, null, { dim: true })}`
+    case "read":
+    case "list":
+      return `  ${prefix} ${name} ${paint(shortPath(args?.path || "."), null, { dim: true })}`
+    case "grep":
+    case "glob":
+      return `  ${prefix} ${name} ${paint(clipText(args?.pattern, 60), null, { dim: true })}`
+    case "task":
+      return `  ${prefix} ${name} ${paint(clipText(args?.description || args?.prompt, 60), null, { dim: true })}`
+    case "todowrite":
+      return null // handled by result preview only
+    case "webfetch":
+      return `  ${prefix} ${name} ${paint(clipText(args?.url, 60), null, { dim: true })}`
+    case "websearch":
+      return `  ${prefix} ${name} ${paint(clipText(args?.query, 60), null, { dim: true })}`
+    case "question":
+      return `  ~ ${paint("Asking questions...", null, { dim: true })}`
+    case "enter_plan":
+      return `  ${paint(SYM.plan, "magenta")} ${paint("Enter Plan", "magenta")}`
+    case "exit_plan":
+      return `  ${paint(SYM.planDone, "green")} ${paint("Submit Plan", "green")}`
+    default:
+      return `  ${prefix} ${name} ${paint(clipText(args ? Object.keys(args).slice(0, 3).join(", ") : "", 40), null, { dim: true })}`
+  }
+}
+
+export function formatToolFinish(toolName, status, durationMs, args) {
+  if (status === "error") {
+    return `  ${paint(SYM.toolErr, "red")} ${paint(toolName, null, { dim: true })} ${paint("error", "red")}${durationMs ? paint(` ${durationMs}ms`, null, { dim: true }) : ""}`
+  }
+  // For completed tools, return null — the start line + result preview is enough
+  return null
+}
+
+export function formatToolResultPreview(toolName, output, status, args) {
+  if (status !== "completed") return null
+  const text = String(output || "").trim()
+
+  switch (toolName) {
+    case "bash": {
+      const lines = text.split("\n").filter(Boolean)
+      if (!lines.length) return null
+      const first = clipText(lines[0], 90)
+      const suffix = lines.length > 1 ? paint(` (+${lines.length - 1} lines)`, null, { dim: true }) : ""
+      return `    ${paint(first, null, { dim: true })}${suffix}`
+    }
+    case "write": {
+      const n = String(args?.content || "").split("\n").filter(Boolean).length
+      return `    ${paint(`+${n} lines`, diffAdd(), { dim: true })}`
+    }
+    case "edit": {
+      const added = String(args?.new_string || "").split("\n").filter(Boolean).length
+      const removed = String(args?.old_string || "").split("\n").filter(Boolean).length
+      const parts = []
+      if (added > 0) parts.push(paint(`+${added}`, diffAdd()))
+      if (removed > 0) parts.push(paint(`-${removed}`, diffDel()))
+      return parts.length ? `    ${parts.join(" ")} ${paint("lines", null, { dim: true })}` : null
+    }
+    case "grep": {
+      const lines = text.split("\n").filter(Boolean)
+      if (text === "no matches" || !lines.length) return `    ${paint("no matches", null, { dim: true })}`
+      return `    ${paint(`${lines.length} matches`, null, { dim: true })}`
+    }
+    case "read":
+      return `    ${paint(`${text.split("\n").length} lines`, null, { dim: true })}`
+    case "glob": {
+      const lines = text.split("\n").filter(Boolean)
+      if (!lines.length) return `    ${paint("no files", null, { dim: true })}`
+      return `    ${paint(`${lines.length} files`, null, { dim: true })}`
+    }
+    case "todowrite": {
+      const todos = Array.isArray(args?.todos) ? args.todos : []
+      if (!todos.length) return null
+      const result = []
+      for (const t of todos.slice(0, 8)) {
+        const s = t.status || "pending"
+        const dot = s === "completed" ? paint(SYM.toolOk, "green")
+          : s === "in_progress" ? paint(SYM.dot, "yellow")
+          : paint(SYM.dotHollow, "#666666")
+        const color = s === "completed" ? "green" : s === "in_progress" ? "yellow" : null
+        const label = s === "in_progress" && t.activeForm ? t.activeForm : t.content
+        result.push(`  ${dot} ${paint(label || "", color, { dim: s === "completed" })}`)
+      }
+      if (todos.length > 8) result.push(paint(`  ... +${todos.length - 8} more`, null, { dim: true }))
+      return result
+    }
+    default:
+      return null
+  }
+}
+
+function formatToolError(error) {
+  if (!error) return null
+  return `  ${paint(clipText(error, 120), "red", { dim: true })}`
+}
+
+// ── Thinking Formatter ──────────────────────────────────
+
+export function formatThinkingHeader() {
+  return `${paint(SYM.dot, "#666666")} ${paint("Thinking", null, { italic: true, dim: true })} ${paint("∨", null, { dim: true })}`
+}
+
+// ── LongAgent Display Formatters ─────────────────────────
+
+export function formatPhaseChange(prevPhase, nextPhase, reason) {
+  const arrow = paint("→", null, { dim: true })
+  const reasonText = reason ? paint(reason, null, { dim: true }) : ""
+  return `${paint(SYM.phase, "magenta")} ${paint("phase", "magenta", { bold: true })} ${paint(prevPhase, null, { dim: true })} ${arrow} ${paint(nextPhase, "magenta", { bold: true })} ${reasonText}`
+}
+
+export function formatStageStarted(stageId, taskCount) {
+  return `${paint(SYM.stage, "#fb923c", { bold: true })} ${paint("stage", "#fb923c", { bold: true })} ${paint(stageId, "white", { bold: true })} ${paint(`(${taskCount} tasks)`, null, { dim: true })}`
+}
+
+export function formatStageFinished(stageId, successCount, failCount) {
+  const status = failCount === 0
+    ? paint("PASS", "green", { bold: true })
+    : paint(`FAIL (${failCount})`, "red", { bold: true })
+  return `${paint(SYM.stage, "#fb923c")} ${paint("stage", "#fb923c")} ${paint(stageId, "white")} ${status} ${paint(`(${successCount} ok)`, null, { dim: true })}`
+}
+
+export function formatTaskDispatched(_stageId, taskId, attempt) {
+  const attemptLabel = attempt > 1 ? paint(` retry#${attempt}`, "yellow") : ""
+  return `   ${paint(SYM.dot, "#666666")} ${paint("task", "cyan")} ${paint(taskId, null, { dim: true })}${attemptLabel}`
+}
+
+export function formatTaskFinished(taskId, status) {
+  const dot = status === "completed" ? paint(SYM.dot, "green") : paint(SYM.dot, "red")
+  const color = status === "completed" ? "green" : "red"
+  return `   ${dot} ${paint(taskId, null, { dim: true })} ${paint(status, color)}`
+}
+
+export function formatHeartbeat(iteration, maxIterations, phase, gate, progress, elapsed) {
+  const iterLabel = maxIterations > 0 ? `${iteration}/${maxIterations}` : String(iteration)
+  const progressLabel = progress?.percentage !== null && progress?.percentage !== undefined
+    ? paint(`${progress.percentage}%`, "green")
+    : paint("...", null, { dim: true })
+  const elapsedLabel = elapsed !== undefined ? paint(`${elapsed}s`, null, { dim: true }) : ""
+  return `${paint(SYM.iteration, "#fb923c")} ${paint("iter", "#fb923c")} ${paint(iterLabel, "white", { bold: true })} phase=${paint(phase || "-", "magenta")} gate=${paint(gate || "-", "cyan")} progress=${progressLabel} ${elapsedLabel}`
+}
+
+export function formatPlanFrozen(planId, stageCount) {
+  return `${paint(SYM.planDone, "green", { bold: true })} ${paint("plan frozen", "green", { bold: true })} ${paint(planId || "", null, { dim: true })} ${paint(`${stageCount} stage(s)`, null, { dim: true })}`
+}
+
+export function formatRecovery(reason, recoveryCount) {
+  return `${paint(SYM.recovery, "yellow", { bold: true })} ${paint("recovery", "yellow", { bold: true })} #${recoveryCount} ${paint(reason || "", null, { dim: true })}`
+}
+
+export function formatAlert(kind, message) {
+  return `${paint(SYM.alert, "red", { bold: true })} ${paint("alert", "red", { bold: true })} [${kind}] ${paint(message || "", null, { dim: true })}`
+}
+
+export function formatIntakeStarted(objective) {
+  const preview = clipText(objective, 80)
+  return `${paint(SYM.phase, "magenta")} ${paint("intake", "magenta", { bold: true })} ${paint(preview, null, { dim: true })}`
+}
+
+export function formatGateChecked(gate, status) {
+  const dot = status === "pass" ? paint(SYM.dot, "green") : paint(SYM.dot, "yellow")
+  return `   ${dot} gate=${paint(gate || "-", "cyan")} ${paint(status || "-", status === "pass" ? "green" : "yellow")}`
+}
+
+// ── Plan Progress Formatter ──────────────────────────────
+
+export function formatPlanProgress(taskProgress) {
+  if (!taskProgress || typeof taskProgress !== "object") return []
+  const entries = Object.entries(taskProgress)
+  if (!entries.length) return []
+
+  const lines = [paint("Plan Progress:", "cyan", { bold: true })]
+  for (const [taskId, tp] of entries) {
+    const status = tp?.status || "pending"
+    const dot = status === "completed"
+      ? paint(SYM.dot, "green")
+      : status === "error"
+        ? paint(SYM.dot, "red")
+        : paint(SYM.dotHollow, "#666666")
+    const color = status === "completed" ? "green" : status === "error" ? "red" : "white"
+    lines.push(`  ${dot} ${taskId} ${paint(status, color)}`)
+  }
+  return lines
+}
+
+// ── Renderer ─────────────────────────────────────────────
+
+export function createActivityRenderer({ output, theme = null }) {
+  _theme = theme
+  const log = typeof output?.appendLog === "function"
+    ? output.appendLog
+    : (text) => console.log(text)
+
+  const toolTimers = new Map()
+  let timerCounter = 0
+  let unsubscribe = null
+
+  function timerKey(sessionId, turnId, toolName) {
+    return `${sessionId || ""}:${turnId || ""}:${toolName}:${timerCounter++}`
+  }
+
+  // Track the latest timer key per tool invocation
+  const activeToolKeys = new Map()
+  // Track tool args for finish formatting
+  const activeToolArgs = new Map()
+
+  function handleEvent(event) {
+    const { type, payload, sessionId, turnId } = event
+
+    switch (type) {
+      case EVENT_TYPES.TOOL_START: {
+        const key = timerKey(sessionId, turnId, payload.tool)
+        const lookupKey = `${sessionId}:${turnId}:${payload.tool}`
+        toolTimers.set(key, Date.now())
+        activeToolKeys.set(lookupKey, key)
+        activeToolArgs.set(lookupKey, payload.args)
+        // Show tool call inline (compact dim line)
+        const startLine = formatToolStart(payload.tool, payload.args)
+        if (startLine) log(startLine)
+        break
+      }
+
+      case EVENT_TYPES.TOOL_FINISH: {
+        const lookupKey = `${sessionId}:${turnId}:${payload.tool}`
+        const key = activeToolKeys.get(lookupKey)
+        const savedArgs = activeToolArgs.get(lookupKey) || payload.args
+        if (key) {
+          toolTimers.delete(key)
+          activeToolKeys.delete(lookupKey)
+          activeToolArgs.delete(lookupKey)
+        }
+        const finishLine = formatToolFinish(payload.tool, payload.status, 0, savedArgs)
+        if (finishLine) log(finishLine)
+        const preview = formatToolResultPreview(payload.tool, payload.output, payload.status, savedArgs)
+        if (preview) {
+          if (Array.isArray(preview)) {
+            for (const line of preview) log(line)
+          } else {
+            log(preview)
+          }
+        }
+        // Blank line after tool for visual spacing
+        if (payload.tool !== "todowrite") log("")
+        break
+      }
+
+      case EVENT_TYPES.TOOL_ERROR: {
+        const lookupKey = `${sessionId}:${turnId}:${payload.tool}`
+        const key = activeToolKeys.get(lookupKey)
+        const savedArgs = activeToolArgs.get(lookupKey) || payload.args
+        if (key) {
+          toolTimers.delete(key)
+          activeToolKeys.delete(lookupKey)
+          activeToolArgs.delete(lookupKey)
+        }
+        log(formatToolFinish(payload.tool, payload.status || "error", 0, savedArgs))
+        const errLine = formatToolError(payload.error)
+        if (errLine) log(errLine)
+        break
+      }
+
+      case EVENT_TYPES.LONGAGENT_PHASE_CHANGED: {
+        log(formatPhaseChange(payload.prevPhase, payload.nextPhase, payload.reason))
+        break
+      }
+
+      case EVENT_TYPES.LONGAGENT_STAGE_STARTED: {
+        log(formatStageStarted(payload.stageId, payload.taskCount))
+        break
+      }
+
+      case EVENT_TYPES.LONGAGENT_STAGE_FINISHED: {
+        log(formatStageFinished(payload.stageId, payload.successCount, payload.failCount))
+        break
+      }
+
+      case EVENT_TYPES.LONGAGENT_STAGE_TASK_DISPATCHED: {
+        log(formatTaskDispatched(payload.stageId, payload.taskId, payload.attempt))
+        break
+      }
+
+      case EVENT_TYPES.LONGAGENT_STAGE_TASK_FINISHED: {
+        log(formatTaskFinished(payload.taskId, payload.status))
+        break
+      }
+
+      case EVENT_TYPES.LONGAGENT_HEARTBEAT: {
+        log(formatHeartbeat(
+          payload.iteration,
+          payload.maxIterations,
+          payload.phase,
+          payload.gate,
+          payload.progress,
+          payload.elapsed
+        ))
+        break
+      }
+
+      case EVENT_TYPES.LONGAGENT_PLAN_FROZEN: {
+        log(formatPlanFrozen(payload.planId, payload.stageCount))
+        break
+      }
+
+      case EVENT_TYPES.LONGAGENT_RECOVERY_ENTERED: {
+        log(formatRecovery(payload.reason, payload.recoveryCount))
+        break
+      }
+
+      case EVENT_TYPES.LONGAGENT_ALERT: {
+        log(formatAlert(payload.kind, payload.message))
+        break
+      }
+
+      case EVENT_TYPES.LONGAGENT_INTAKE_STARTED: {
+        log(formatIntakeStarted(payload.objective))
+        break
+      }
+
+      case EVENT_TYPES.LONGAGENT_GATE_CHECKED: {
+        log(formatGateChecked(payload.gate, payload.status))
+        break
+      }
+
+      case EVENT_TYPES.SESSION_COMPACTED: {
+        log(`${paint(SYM.phase, "magenta")} ${paint("context compacted", "magenta", { dim: true })}`)
+        break
+      }
+    }
+  }
+
+  return {
+    start() {
+      if (unsubscribe) return
+      unsubscribe = EventBus.subscribe(handleEvent)
+    },
+    stop() {
+      if (unsubscribe) {
+        unsubscribe()
+        unsubscribe = null
+      }
+      toolTimers.clear()
+      activeToolKeys.clear()
+      activeToolArgs.clear()
+    }
+  }
+}