@kkelly-offical/kkcode 0.1.6 → 0.2.1

package/src/repl/core-shell.mjs

@@ -0,0 +1,208 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises"
+import { dirname } from "node:path"
+import { paint } from "../theme/color.mjs"
+import { resolveMode } from "../session/engine.mjs"
+
+export function configuredProviders(config, listProvidersFn) {
+  const builtins = new Set(listProvidersFn())
+  const out = []
+  for (const [name, value] of Object.entries(config.provider || {})) {
+    if (name === "default") continue
+    if (name === "strict_mode") continue
+    if (name === "model_context") continue
+    if (!value || typeof value !== "object") continue
+    const type = value.type || name
+    if (builtins.has(type)) out.push(name)
+  }
+  return out
+}
+
+export async function loadHistoryLines(filePath, size) {
+  try {
+    const raw = await readFile(filePath, "utf8")
+    return raw.split("\n").filter(Boolean).slice(-size)
+  } catch {
+    return []
+  }
+}
+
+export async function saveHistoryLines(filePath, size, lines) {
+  try {
+    await mkdir(dirname(filePath), { recursive: true })
+    const finalLines = [...lines].slice(-size)
+    await writeFile(filePath, finalLines.join("\n") + (finalLines.length ? "\n" : ""), "utf8")
+  } catch {}
+}
+
+export function clearScreen(output = process.stdout) {
+  if (!output?.isTTY) return
+  output.write("\x1Bc")
+}
+
+export function resolveProviderDefaultModel(config, providerType, fallback = "") {
+  return (
+    config.provider?.[providerType]?.default_model ||
+    config.provider?.[config.provider?.default]?.default_model ||
+    fallback
+  )
+}
+
+export function createInitialReplState(config, { newSessionIdFn }) {
+  const providerType = config.provider.default
+  const state = {
+    sessionId: newSessionIdFn(),
+    mode: resolveMode(config.agent.default_mode),
+    providerType,
+    model: ""
+  }
+  state.model = resolveProviderDefaultModel(config, providerType)
+  return state
+}
+
+export function collectMcpStatusLines(theme, entries, tools) {
+  const lines = []
+  for (const entry of entries) {
+    if (entry.ok) {
+      const toolCount = tools.filter((tool) => tool.server === entry.name).length
+      lines.push(
+        paint(`  mcp ✓ ${entry.name}`, theme.semantic.success) +
+          paint(` (${toolCount} tools, ${entry.transport})`, theme.base.muted)
+      )
+      continue
+    }
+    const reason = entry.error || entry.reason || "unknown"
+    lines.push(
+      paint(`  mcp ✗ ${entry.name}`, theme.semantic.error) +
+        paint(` ${reason}`, theme.base.muted)
+    )
+  }
+  return lines
+}
+
+export function startSplash({
+  paintFn = paint,
+  stdout = process.stdout,
+  version = "v0.1.27"
+} = {}) {
+  if (!stdout?.isTTY) return { update() {}, stop() {} }
+
+  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+  const logo = [
+    "  ██╗  ██╗ ██╗  ██╗  ██████╗  ██████╗  ██████╗  ███████╗ ",
+    "  ██║ ██╔╝ ██║ ██╔╝ ██╔════╝ ██╔═══██╗ ██╔══██╗ ██╔════╝ ",
+    "  █████╔╝  █████╔╝  ██║      ██║   ██║ ██║  ██║ █████╗   ",
+    "  ██╔═██╗  ██╔═██╗  ██║      ██║   ██║ ██║  ██║ ██╔══╝   ",
+    "  ██║  ██╗ ██║  ██╗ ╚██████╗ ╚██████╔╝ ██████╔╝ ███████╗ ",
+    "  ╚═╝  ╚═╝ ╚═╝  ╚═╝  ╚═════╝  ╚═════╝  ╚═════╝  ╚══════╝ "
+  ]
+  const tagline = "CLI Personal Assistant"
+  const wave = [
+    "#4af5f0", "#3de8f5", "#30dbfa", "#38c8ff", "#40b5ff",
+    "#58a0ff", "#708bff", "#8876ff", "#a061ff", "#b84cff",
+    "#d037ff", "#e828f0", "#f034d0", "#f040b0", "#f04c90",
+    "#f040b0", "#f034d0", "#e828f0", "#d037ff", "#b84cff",
+    "#a061ff", "#8876ff", "#708bff", "#58a0ff", "#40b5ff",
+    "#38c8ff", "#30dbfa", "#3de8f5"
+  ]
+
+  function charColor(ch, hex) {
+    if (ch === " " || ch === "\n") return ch
+    const r = parseInt(hex.slice(1, 3), 16)
+    const g = parseInt(hex.slice(3, 5), 16)
+    const b = parseInt(hex.slice(5, 7), 16)
+    return `\x1b[1;38;2;${r};${g};${b}m${ch}\x1b[0m`
+  }
+
+  let tick = 0
+  let status = "loading config..."
+  let steps = []
+  let revealChars = 0
+  const totalChars = logo[0].length
+  const revealSpeed = 3
+
+  function render() {
+    const cols = stdout.columns || 80
+    const rows = stdout.rows || 24
+    const lines = []
+    const contentHeight = logo.length + 4 + steps.length + 2
+    const topPad = Math.max(0, Math.floor((rows - contentHeight) / 2))
+    for (let i = 0; i < topPad; i++) lines.push("")
+
+    const visible = Math.min(revealChars, totalChars)
+    for (let row = 0; row < logo.length; row++) {
+      const line = logo[row]
+      const pad = Math.max(0, Math.floor((cols - line.length) / 2))
+      let out = " ".repeat(pad)
+      for (let col = 0; col < line.length; col++) {
+        if (col >= visible) {
+          out += " "
+          continue
+        }
+        const ch = line[col]
+        const waveIdx = (col + tick * 2 + row * 3) % wave.length
+        out += charColor(ch, wave[waveIdx])
+      }
+      lines.push(out)
+    }
+
+    const tagFull = `${tagline}  ·  ${version}`
+    if (visible >= totalChars) {
+      const tagPad = Math.max(0, Math.floor((cols - tagFull.length) / 2))
+      const tagAlpha = Math.min(1, (revealChars - totalChars) / 20)
+      const brightness = Math.round(100 + 155 * tagAlpha)
+      const hex = brightness.toString(16).padStart(2, "0")
+      const tagHex = `#${hex}${hex}${hex}`
+      lines.push(" ".repeat(tagPad) + paintFn(tagFull, tagHex, { dim: tagAlpha < 0.5 }))
+    } else {
+      lines.push("")
+    }
+
+    if (visible >= totalChars) {
+      const barWidth = Math.min(40, cols - 4)
+      const barPad = Math.max(0, Math.floor((cols - barWidth) / 2))
+      let bar = ""
+      for (let i = 0; i < barWidth; i++) {
+        const ci = (i + tick) % wave.length
+        bar += charColor("─", wave[ci])
+      }
+      lines.push(" ".repeat(barPad) + bar)
+    } else {
+      lines.push("")
+    }
+
+    lines.push("")
+    for (const step of steps) {
+      const pad = Math.max(0, Math.floor((cols - step.length - 4) / 2))
+      lines.push(" ".repeat(pad) + paintFn(`  ✓ ${step}`, "#3fd487"))
+    }
+
+    const spinChar = frames[tick % frames.length]
+    const spinLine = `${spinChar} ${status}`
+    const spinPad = Math.max(0, Math.floor((cols - spinLine.length - 2) / 2))
+    lines.push(" ".repeat(spinPad) + paintFn(`  ${spinLine}`, "#6ec1ff", { bold: true }))
+
+    stdout.write("\x1B[?25l")
+    stdout.write("\x1Bc")
+    stdout.write(lines.join("\n"))
+  }
+
+  render()
+  const timer = setInterval(() => {
+    tick += 1
+    if (revealChars < totalChars + 30) revealChars += revealSpeed
+    render()
+  }, 50)
+
+  return {
+    update(text) {
+      steps.push(status.replace("...", ""))
+      status = text
+      render()
+    },
+    stop() {
+      clearInterval(timer)
+      stdout.write("\x1B[?25h")
+      stdout.write("\x1Bc")
+    }
+  }
+}

package/src/repl/dialog-router.mjs

@@ -0,0 +1,87 @@
+export const QUESTION_SKIPPED = "(skipped)"
+
+export function activateNextQuestionState(queue = []) {
+  if (!queue.length) {
+    return {
+      pendingQuestion: null,
+      questionIndex: 0,
+      questionOptionSelected: 0,
+      questionMultiSelected: {},
+      questionCustomMode: false,
+      questionCustomInput: "",
+      questionCustomCursor: 0,
+      questionAnswers: {}
+    }
+  }
+
+  const [pendingQuestion, ...rest] = queue
+  return {
+    queue: rest,
+    pendingQuestion,
+    questionIndex: 0,
+    questionOptionSelected: 0,
+    questionMultiSelected: {},
+    questionCustomMode: false,
+    questionCustomInput: "",
+    questionCustomCursor: 0,
+    questionAnswers: {}
+  }
+}
+
+export function commitQuestionAnswer(state) {
+  const questions = state.pendingQuestion?.questions || []
+  const current = questions[state.questionIndex]
+  if (!current) return state
+
+  const nextAnswers = { ...state.questionAnswers }
+  if (state.questionCustomMode) {
+    nextAnswers[current.id] = state.questionCustomInput || ""
+    return {
+      ...state,
+      questionAnswers: nextAnswers,
+      questionCustomMode: false,
+      questionCustomInput: "",
+      questionCustomCursor: 0
+    }
+  }
+
+  if (current.multi) {
+    const selected = state.questionMultiSelected[current.id] || new Set()
+    const values = [...selected]
+      .map((index) => {
+        const opt = (current.options || [])[index]
+        return opt ? (opt.value || opt.label) : ""
+      })
+      .filter(Boolean)
+    nextAnswers[current.id] = values.join(", ")
+    return { ...state, questionAnswers: nextAnswers }
+  }
+
+  const option = (current.options || [])[state.questionOptionSelected]
+  if (option) nextAnswers[current.id] = option.value || option.label
+  return { ...state, questionAnswers: nextAnswers }
+}
+
+export function advanceQuestionState(state) {
+  const questions = state.pendingQuestion?.questions || []
+  if (state.questionIndex < questions.length - 1) {
+    return {
+      ...state,
+      questionIndex: state.questionIndex + 1,
+      questionOptionSelected: 0,
+      questionCustomMode: false,
+      questionCustomInput: "",
+      questionCustomCursor: 0
+    }
+  }
+  return { ...state, shouldSubmit: true }
+}
+
+export function finalizeQuestionAnswers(pendingQuestion, questionAnswers = {}) {
+  const answers = { ...questionAnswers }
+  const questions = pendingQuestion?.questions || []
+  for (const question of questions) {
+    if (!(question.id in answers)) answers[question.id] = QUESTION_SKIPPED
+  }
+  return answers
+}

package/src/repl/input-engine.mjs

@@ -0,0 +1,76 @@
+export async function collectInput(rl, promptStr) {
+  const first = (await rl.question(promptStr)).trim()
+  if (!first) return ""
+
+  if (first === '"""' || first.startsWith('"""')) {
+    const lines = []
+    if (first !== '"""') lines.push(first.slice(3))
+    while (true) {
+      const next = await rl.question("... ")
+      if (next.trim() === '"""') break
+      lines.push(next)
+    }
+    return lines.join("\n").trim()
+  }
+
+  if (first.endsWith("\\")) {
+    const lines = [first.slice(0, -1)]
+    while (true) {
+      const next = await rl.question("... ")
+      if (next.endsWith("\\")) lines.push(next.slice(0, -1))
+      else {
+        lines.push(next)
+        break
+      }
+    }
+    return lines.join("\n").trim()
+  }
+
+  return first
+}
+
+export function resolveHistoryNavigation(history, historyIndex, keyName) {
+  if (!Array.isArray(history) || history.length === 0) {
+    return { historyIndex, value: "", changed: false }
+  }
+
+  if (keyName === "up") {
+    const nextIndex = Math.max(0, historyIndex - 1)
+    return {
+      historyIndex: nextIndex,
+      value: history[nextIndex] || "",
+      changed: nextIndex !== historyIndex
+    }
+  }
+
+  if (historyIndex < history.length - 1) {
+    const nextIndex = historyIndex + 1
+    return {
+      historyIndex: nextIndex,
+      value: history[nextIndex] || "",
+      changed: true
+    }
+  }
+
+  return {
+    historyIndex: history.length,
+    value: "",
+    changed: historyIndex !== history.length
+  }
+}
+
+export function shouldApplySuggestionOnEnter(input, suggestions, selectedSuggestion) {
+  if (!Array.isArray(suggestions) || suggestions.length === 0) return false
+  if (!String(input || "").startsWith("/")) return false
+
+  const body = String(input || "").slice(1)
+  const firstSpace = body.indexOf(" ")
+  if (firstSpace >= 0) return false
+
+  const token = body.trim()
+  if (!token) return true
+
+  const idx = Math.max(0, Math.min(selectedSuggestion || 0, suggestions.length - 1))
+  const chosen = suggestions[idx]
+  return Boolean(chosen && chosen.name !== token)
+}

package/src/repl/keymap.mjs

@@ -0,0 +1,7 @@
+export const MODE_CYCLE_ORDER = ["assistant", "agent", "longagent", "plan"]
+
+export function nextMode(currentMode, order = MODE_CYCLE_ORDER) {
+  const idx = order.indexOf(currentMode)
+  const nextIdx = idx >= 0 ? (idx + 1) % order.length : 0
+  return order[nextIdx]
+}

package/src/repl/operator-surface.mjs

@@ -0,0 +1,15 @@
+export function buildOperatorSnapshot({ runtimeSummary = null, backgroundSummary = null } = {}) {
+  const actions = []
+  if (runtimeSummary?.recoverableCount) {
+    actions.push(`recoverable sessions available: ${runtimeSummary.recoverableCount}`)
+  }
+  const recentTerminal = backgroundSummary?.recent_terminal || []
+  for (const item of recentTerminal.slice(0, 2)) {
+    if (item?.next_action) actions.push(`${item.id}: ${item.next_action}`)
+  }
+  return {
+    recoverableCount: Number(runtimeSummary?.recoverableCount || 0),
+    activeBackground: Number(backgroundSummary?.active || 0),
+    actions
+  }
+}

package/src/repl/permission-flow.mjs

@@ -0,0 +1,49 @@
+export const POLICY_CHOICES = [
+  { label: "Auto", value: "auto", desc: "auto-approve safe reads, review risky tools" },
+  { label: "YOLO", value: "yolo", desc: "allow permission checks without prompts" },
+  { label: "Ask", value: "ask", desc: "prompt before each tool call" },
+  { label: "Allow", value: "allow", desc: "legacy allow all tool calls" },
+  { label: "Deny", value: "deny", desc: "deny all tool calls" },
+  { label: "Session Clear", value: "session-clear", desc: "clear cached grants" }
+]
+
+function currentPermissionValue(permissionConfigOrValue = "auto") {
+  if (typeof permissionConfigOrValue === "string") return permissionConfigOrValue
+  return permissionConfigOrValue.mode || permissionConfigOrValue.default_policy || "auto"
+}
+
+export function createPolicyPickerState(current = "auto") {
+  const value = currentPermissionValue(current)
+  const idx = POLICY_CHOICES.findIndex((choice) => choice.value === value)
+  return { selected: Math.max(0, idx) }
+}
+
+export function applyPolicyChoice(choice, { permissionConfig = {}, sessionId, clearSession } = {}) {
+  if (!choice) return { message: null, permissionConfig }
+  if (choice.value === "session-clear") {
+    clearSession?.(sessionId)
+    return {
+      message: "permission session cache cleared",
+      permissionConfig
+    }
+  }
+
+  if (["auto", "yolo"].includes(choice.value)) {
+    return {
+      message: `permission mode → ${choice.value}`,
+      permissionConfig: {
+        ...permissionConfig,
+        mode: choice.value
+      }
+    }
+  }
+
+  return {
+    message: `permission policy → ${choice.value}`,
+    permissionConfig: {
+      ...permissionConfig,
+      mode: "manual",
+      default_policy: choice.value
+    }
+  }
+}

package/src/repl/runtime-facade.mjs

@@ -0,0 +1,36 @@
+import { listSessions } from "../session/store.mjs"
+import { BackgroundManager } from "../orchestration/background-manager.mjs"
+import { summarizeSessionRuntimeState } from "../session/runtime-state.mjs"
+import { collectMcpSummary, collectSkillSummary } from "./state-store.mjs"
+
+export async function buildReplRuntimeSnapshot({
+  cwd = process.cwd(),
+  state,
+  customCommands = [],
+  providers = [],
+  mcpRegistry,
+  skillRegistry,
+  recoveryEnabled = true
+}) {
+  const recentSessions = await listSessions({ cwd, limit: 6, includeChildren: false }).catch(() => [])
+  const mcpSummary = collectMcpSummary(mcpRegistry)
+  const skillSummary = collectSkillSummary(skillRegistry)
+  const backgroundSummary = await BackgroundManager.summary().catch(() => null)
+  const runtimeSummary = await summarizeSessionRuntimeState({
+    sessionId: state?.sessionId || null,
+    cwd,
+    recoveryEnabled
+  }).catch(() => null)
+
+  return {
+    state,
+    providers,
+    recentSessions,
+    mcpSummary,
+    skillSummary,
+    backgroundSummary,
+    runtimeSummary,
+    customCommandCount: customCommands.length,
+    cwd
+  }
+}

package/src/repl/slash-router.mjs

@@ -0,0 +1,62 @@
+export const DEFAULT_SLASH_ALIASES = {
+  "/h": "/help",
+  "/?": "/help",
+  "/n": "/new",
+  "/s": "/session",
+  "/k": "/keys",
+  "/r": "/resume",
+  "/m": "/mode",
+  "/p": "/provider",
+  "/q": "/exit"
+}
+
+export function buildSlashCatalog({ builtinSlash = [], customCommands = [], skills = [] } = {}) {
+  const custom = customCommands.map((cmd) => ({
+    name: cmd.name,
+    desc: `custom (${cmd.scope || "project"})`
+  }))
+  const customNames = new Set(custom.map((item) => item.name))
+  const skillEntries = skills
+    .filter((skill) => !customNames.has(skill.name))
+    .map((skill) => ({ name: skill.name, desc: `skill (${skill.type})` }))
+  return [...builtinSlash, ...custom, ...skillEntries]
+}
+
+export function slashQuery(inputLine) {
+  if (!String(inputLine || "").startsWith("/")) return null
+  const raw = String(inputLine).slice(1)
+  const firstSpace = raw.indexOf(" ")
+  return (firstSpace >= 0 ? raw.slice(0, firstSpace) : raw).trim()
+}
+
+export function slashSuggestions(inputLine, options = {}) {
+  const token = slashQuery(inputLine)
+  if (token === null) return []
+  const all = buildSlashCatalog(options)
+  const q = token.toLowerCase()
+  return all
+    .map((item) => {
+      const name = item.name.toLowerCase()
+      let rank = 99
+      if (!q) rank = 0
+      else if (name === q) rank = 0
+      else if (name.startsWith(q)) rank = 1
+      else if (name.includes(q)) rank = 2
+      return { ...item, rank }
+    })
+    .filter((item) => item.rank < 99)
+    .sort((a, b) => (a.rank - b.rank) || a.name.localeCompare(b.name))
+}
+
+export function applySuggestionToInput(current, suggestionName) {
+  const raw = String(current || "")
+  if (!raw.startsWith("/")) return raw
+  const body = raw.slice(1)
+  const firstSpace = body.indexOf(" ")
+  if (firstSpace < 0) return `/${suggestionName} `
+  return `/${suggestionName}${body.slice(firstSpace)}`
+}
+
+export function normalizeSlashAlias(line, aliases = DEFAULT_SLASH_ALIASES) {
+  return aliases[String(line || "")] || line
+}

package/src/repl/state-store.mjs

@@ -0,0 +1,29 @@
+export function collectMcpSummary(registry) {
+  const snapshot = registry.healthSnapshot()
+  const tools = registry.listTools()
+  const byServer = {}
+  for (const tool of tools) {
+    const server = tool.server || "unknown"
+    byServer[server] = (byServer[server] || 0) + 1
+  }
+  const healthy = snapshot.filter((item) => item.ok).length
+  return {
+    configured: snapshot.length,
+    healthy,
+    unhealthy: snapshot.length - healthy,
+    tools: tools.length,
+    byServer,
+    entries: snapshot
+  }
+}
+
+export function collectSkillSummary(registry) {
+  const list = registry.isReady() ? registry.list() : []
+  return {
+    total: list.length,
+    template: list.filter((s) => s.type === "template").length,
+    skillMd: list.filter((s) => s.type === "skill_md").length,
+    mcpPrompt: list.filter((s) => s.type === "mcp_prompt").length,
+    programmable: list.filter((s) => s.type === "mjs").length
+  }
+}

package/src/repl/turn-controller.mjs

@@ -0,0 +1,58 @@
+import { executeTurn } from "../session/engine.mjs"
+import { HookBus } from "../plugin/hook-bus.mjs"
+import { extractImageRefs, buildContentBlocks } from "../tool/image-util.mjs"
+
+export async function executePromptTurn({
+  prompt,
+  state,
+  ctx,
+  streamSink = null,
+  pendingImages = [],
+  signal = null,
+  deps = {}
+}) {
+  const extractImageRefsFn = deps.extractImageRefs || extractImageRefs
+  const buildContentBlocksFn = deps.buildContentBlocks || buildContentBlocks
+  const chatParamsFn = deps.chatParams || HookBus.chatParams.bind(HookBus)
+  const executeTurnFn = deps.executeTurn || executeTurn
+  const cwd = deps.cwd || process.cwd()
+
+  const { text: cleanedPrompt, imagePaths, imageUrls = [] } = extractImageRefsFn(prompt, cwd)
+  const effectivePrompt = cleanedPrompt ?? prompt
+  let contentBlocks = null
+
+  if (imagePaths.length || imageUrls.length || pendingImages.length) {
+    contentBlocks = await buildContentBlocksFn(effectivePrompt, imagePaths, imageUrls)
+    if (typeof contentBlocks === "string") {
+      contentBlocks = [{ type: "text", text: contentBlocks }]
+    }
+    for (const img of pendingImages) {
+      if (img && img.type === "image") contentBlocks.push(img)
+    }
+  }
+
+  const chatParams = await chatParamsFn({
+    prompt: effectivePrompt,
+    mode: state.mode,
+    model: state.model,
+    providerType: state.providerType,
+    sessionId: state.sessionId
+  })
+
+  return {
+    result: await executeTurnFn({
+      prompt: chatParams.prompt ?? effectivePrompt,
+      contentBlocks,
+      mode: chatParams.mode ?? state.mode,
+      model: chatParams.model ?? state.model,
+      sessionId: state.sessionId,
+      configState: ctx.configState,
+      providerType: chatParams.providerType ?? state.providerType,
+      longagentImpl: state.longagentImpl ?? null,
+      signal,
+      output: streamSink && typeof streamSink === "function"
+        ? { write: streamSink }
+        : null
+    })
+  }
+}

package/src/repl/verification.mjs

@@ -0,0 +1,23 @@
+export function buildReplSmokeChecklist() {
+  return [
+    "start repl in tty mode",
+    "verify /help and /status output",
+    "verify slash suggestion and selection flow",
+    "submit one normal prompt turn",
+    "exercise one permission or question dialog",
+    "inspect background/task visibility",
+    "confirm --help and --version CLI outputs"
+  ]
+}
+
+export function summarizeVerificationResults(results = []) {
+  const total = results.length
+  const passed = results.filter((item) => item?.ok === true).length
+  const failed = total - passed
+  return {
+    total,
+    passed,
+    failed,
+    ok: failed === 0
+  }
+}