@rind-ai/cli 0.4.1 → 0.6.1

package/lib/local-slash-commands.js

@@ -0,0 +1,217 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { currentTheme, setTheme, themeNames, themeOptions } from "./theme.js";
+
+export const LOCAL_SLASH_COMMANDS = Object.freeze([
+  { name: "compact", description: "Compact current session context", usage: "/compact" },
+  { name: "config", description: "Show config guidance", usage: "/config" },
+  { name: "doctor", description: "Run local setup diagnostics", usage: "/doctor" },
+  { name: "effort", description: "Show or change reasoning effort", usage: "/effort [low | medium | high | xhigh | max]" },
+  { name: "goal", description: "View or control the active goal", usage: "/goal [pause | resume | clear | objective]" },
+  { name: "help", description: "Show commands", usage: "/help [command]" },
+  { name: "init", description: "Draft RIND.md", usage: "/init [project|user]" },
+  { name: "login", description: "Show login setup guidance", usage: "/login" },
+  { name: "model", description: "Show or change the active model", usage: "/model | /model set <model>" },
+  { name: "sessions", description: "List recent sessions", usage: "/sessions [limit]" },
+  { name: "skill", description: "List skills", usage: "/skill [list]" },
+  { name: "status", description: "Show surface status", usage: "/status" },
+  { name: "team", description: "Manage the current Team", usage: "/team create [project-id] | /team init | /team list | /team blueprint [id] | /team add <description>" },
+  { name: "theme", description: "Switch the CLI color theme", usage: "/theme [latte | frappe | macchiato | mocha]" },
+]);
+
+export async function loadLocalSettings(
+  rindHome = process.env.RIND_HOME || path.join(homedir(), ".rind"),
+  workspaceRoot = process.cwd(),
+) {
+  const userSettingsPath = path.join(rindHome, "settings.json");
+  const projectSettingsPath = path.resolve(workspaceRoot, ".rind", "settings.json");
+  const project = await readSettingsFile(projectSettingsPath);
+  if (project.exists && isCompleteProjectSettings(project.data)) {
+    return buildLocalSettings(projectSettingsPath, project.data, project.error, project.exists);
+  }
+  const settings = await readSettingsFile(userSettingsPath);
+  return buildLocalSettings(userSettingsPath, settings.data, settings.error, settings.exists);
+}
+
+async function readSettingsFile(settingsPath) {
+  let data = {};
+  let settingsExists = false;
+  let error = "";
+  try {
+    data = JSON.parse(await readFile(settingsPath, "utf8"));
+    settingsExists = true;
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+      throw new Error("settings.json must contain a JSON object");
+    }
+  } catch (cause) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) data = {};
+    if (cause?.code !== "ENOENT") {
+      error = cause instanceof Error ? cause.message : String(cause);
+    }
+  }
+  return { data, exists: settingsExists, error };
+}
+
+function buildLocalSettings(settingsPath, data, error, exists) {
+  return {
+    path: settingsPath,
+    exists,
+    error,
+    model: stringValue(data.model) || "gpt-4o-mini",
+    baseUrl: stringValue(data.baseUrl) || "https://api.openai.com/v1",
+    reasoningEffort: stringValue(data.reasoningEffort) || "",
+    hasApiKey: Boolean(stringValue(data.apiKey)),
+  };
+}
+
+function isCompleteProjectSettings(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return false;
+  const apiKey = stringValue(data.apiKey);
+  const baseUrl = stringValue(data.baseUrl);
+  const model = stringValue(data.model);
+  try {
+    const url = new URL(baseUrl);
+    return Boolean(apiKey && model && url.hostname && (url.protocol === "http:" || url.protocol === "https:"));
+  } catch {
+    return false;
+  }
+}
+
+export async function executeLocalSlashCommand(input, context = {}) {
+  const match = String(input || "").trim().match(/^\/([^\s]+)(?:\s+([\s\S]*))?$/);
+  if (!match) return null;
+  const name = match[1].toLowerCase();
+  const argument = String(match[2] || "").trim();
+  if (name === "config") return configResult(context.settings, argument);
+  if (name === "login") return argument ? usageResult("/login") : { text: "Login/config setup is not implemented yet.\nSet apiKey in ~/.rind/settings.json." };
+  if (name === "status") {
+    if (!argument && context.runtimeInitialized) return null;
+    return statusResult(context, argument);
+  }
+  if (name === "doctor") return doctorResult(context, argument);
+  if (name === "help") return helpResult(argument, context.commands || []);
+  if (name === "theme") return themeResult(argument, context);
+  if (name === "model" && !argument && !context.interactive) return { text: `Model: ${context.settings?.model || "unknown"}` };
+  return null;
+}
+
+function usageResult(usage) {
+  return { text: `Usage: ${usage}` };
+}
+
+function configResult(settings = {}, argument) {
+  if (argument) return usageResult("/config");
+  const apiKey = settings.hasApiKey ? "set" : "unset";
+  const reasoning = settings.reasoningEffort || "unset";
+  const entries = [
+    { label: "settings", value: settings.path || "~/.rind/settings.json", state: settings.exists ? "found" : "missing" },
+    { label: "apiKey", value: apiKey },
+    { label: "baseUrl", value: settings.baseUrl || "https://api.openai.com/v1" },
+    { label: "model", value: settings.model || "unknown" },
+    { label: "reasoningEffort", value: reasoning },
+  ];
+  return {
+    text: [
+      "Config:",
+      `- settings: ${entries[0].value} (${entries[0].state})`,
+      `- apiKey: ${apiKey}`,
+      `- baseUrl: ${entries[2].value}`,
+      `- model: ${entries[3].value}`,
+      `- reasoningEffort: ${reasoning}`,
+    ].join("\n"),
+    display: { type: "config", entries },
+  };
+}
+
+function statusResult(context, argument) {
+  if (argument) return usageResult("/status");
+  const session = String(context.sessionInfo?.session_id || "none");
+  const model = String(context.settings?.model || context.sessionInfo?.model || "unknown");
+  const runtime = context.runtimeInitialized ? "ready" : context.runtimeStarted ? "starting" : "not started";
+  return {
+    text: [
+      "Status:",
+      `Session: ${session}`,
+      `Model: ${model}`,
+      `Runtime: ${runtime}`,
+      "Messages: unknown",
+    ].join("\n"),
+    display: { type: "status", session, model, debug: false, messages: "unknown", runtime },
+  };
+}
+
+function doctorResult(context, argument) {
+  if (argument) return usageResult("/doctor");
+  const settings = context.settings || {};
+  const checks = [
+    check(!settings.error, "Settings", settings.error || (settings.exists ? "found" : "missing")),
+    check(settings.hasApiKey, "API key", settings.hasApiKey ? "set" : "unset"),
+    check(Boolean(settings.model), "Model", settings.model || "unset"),
+    check(Boolean(context.cwd), "Working directory", context.cwd || "unknown"),
+  ];
+  const failures = checks.filter((item) => item.status === "fail").length;
+  const warnings = checks.filter((item) => item.status === "warn").length;
+  return {
+    text: [
+      "Doctor:",
+      ...checks.map((item) => `- [${item.status}] ${item.name}: ${item.detail}`),
+      `Overall: ${failures} failure(s), ${warnings} warning(s).`,
+    ].join("\n"),
+    display: { type: "doctor", checks, failures, warnings, next_steps: [] },
+  };
+}
+
+function check(ok, name, detail) {
+  return { status: ok ? "ok" : "fail", name, detail };
+}
+
+function helpResult(argument, commands) {
+  const name = argument.replace(/^\//, "").toLowerCase();
+  const visible = commands.filter((command) => (!name || command.name === name || command.aliases?.includes(name)));
+  if (name && !visible.length) return { text: `Unknown command: /${name}\nRun /help to see available commands.` };
+  const selected = name ? visible[0] : null;
+  const text = selected
+    ? `/${selected.name}\n${selected.description}\nUsage: ${selected.usage || `/${selected.name}`}`
+    : ["Commands:", ...visible.map((command) => `/${command.name} - ${command.description}`)].join("\n");
+  return {
+    text,
+    display: { type: "help", ...(selected ? { command: selected } : { commands: visible }) },
+  };
+}
+
+function themeResult(argument, context = {}) {
+  const requested = argument.replace(/^\//, "").trim();
+  if (requested) {
+    const previous = currentTheme();
+    const applied = setTheme(requested);
+    if (!applied) {
+      return { text: `Unknown theme "${requested}". Available: ${themeNames().join(", ")}.` };
+    }
+    context.persistTheme?.(applied.name);
+    return {
+      text: `Theme: ${applied.name}`,
+      display: {
+        type: "theme",
+        changed: true,
+        previous: previous.name,
+        current: applied.name,
+        flavors: themeOptions(),
+      },
+    };
+  }
+  const current = currentTheme();
+  return {
+    text: `Theme: ${current.name}`,
+    display: {
+      type: "theme",
+      changed: false,
+      current: current.name,
+      flavors: themeOptions(),
+    },
+  };
+}
+
+function stringValue(value) {
+  return typeof value === "string" ? value.trim() : "";
+}

package/lib/markdown-lines.js

@@ -0,0 +1,103 @@
+const INLINE_TOKEN_RE = /(\[[^\]]+\]\([^)]+\)|`[^`]+`|\*\*[^*]+\*\*)/g;
+const PLAIN_TEXT_RE = /[`*#>|\[]/;
+
+export function renderMarkdownishLine(line, color) {
+  const heading = line.match(/^(#{1,6})\s+(.+?)\s*$/);
+  if (heading) {
+    return renderInline(heading[2], color, "heading");
+  }
+
+  const quote = line.match(/^(\s*)>\s?(.*)$/);
+  if (quote) {
+    return `${quote[1]}${dim("│ ", color)}${renderInline(quote[2], color)}`;
+  }
+
+  const list = line.match(/^(\s*)([-*+]|\d+\.)\s+(.*)$/);
+  if (list) {
+    const marker = /^\d+\.$/.test(list[2]) ? list[2] : "–";
+    return `${list[1]}${dim(`${marker} `, color)}${renderInline(list[3], color)}`;
+  }
+
+  return renderInline(line, color);
+}
+
+export function renderInline(text, color, baseStyle = "") {
+  const source = String(text || "");
+  let output = "";
+  let index = 0;
+  for (const match of source.matchAll(INLINE_TOKEN_RE)) {
+    output += styled(source.slice(index, match.index), color, baseStyle);
+    output += renderInlineToken(match[0], color, baseStyle);
+    index = match.index + match[0].length;
+  }
+  return output + styled(source.slice(index), color, baseStyle);
+}
+
+export function renderInlineToken(token, color, baseStyle) {
+  const link = token.match(/^\[([^\]]+)\]\(([^)]+)\)$/);
+  if (link) {
+    return `${renderInline(link[1], color, baseStyle)} ${dim(`(${link[2]})`, color)}`;
+  }
+  if (token.startsWith("`") && token.endsWith("`")) {
+    return styled(token.slice(1, -1), color, "inlineCode");
+  }
+  if (token.startsWith("**") && token.endsWith("**")) {
+    return styled(token.slice(2, -2), color, baseStyle || "emphasis");
+  }
+  return token;
+}
+
+export function isPlainLine(line) {
+  if (!line) {
+    return true;
+  }
+  if (PLAIN_TEXT_RE.test(line)) {
+    return false;
+  }
+  const stripped = line.trimStart();
+  return !stripped.match(/^([-*+]|\d+\.)\s+/);
+}
+
+export function isTableLine(line, inCodeBlock) {
+  const stripped = line.trim();
+  return !inCodeBlock && stripped.includes("|") && stripped.split("|").length > 2;
+}
+
+export function parseTableRow(line) {
+  let stripped = line.trim();
+  if (stripped.startsWith("|")) {
+    stripped = stripped.slice(1);
+  }
+  if (stripped.endsWith("|")) {
+    stripped = stripped.slice(0, -1);
+  }
+  return stripped.split("|").map((cell) => cell.trim());
+}
+
+export function codeOpenLabel(label) {
+  return label ? `┌ code ${label}` : "┌ code";
+}
+
+import { paintRaw } from "./theme.js";
+
+export function styled(text, color, style) {
+  if (!text || !color || !style) {
+    return text;
+  }
+  const roles = {
+    codeBlock: "fence",
+    emphasis: "warning",
+    heading: "accent",
+    inlineCode: "code",
+    tableHeader: "accent",
+  };
+  const role = roles[style] || "warning";
+  const painted = paintRaw[role](text);
+  return style === "heading" || style === "tableHeader" || style === "emphasis"
+    ? paintRaw.bold(painted)
+    : painted;
+}
+
+export function dim(text, color) {
+  return color ? `\x1b[2m${text}\x1b[0m` : text;
+}

package/lib/model-menu-state.js

@@ -1,50 +1,50 @@
-export function createModelMenuState(models, currentModel = "") {
-  const items = normalizeModels(models, currentModel);
-  let selected = Math.max(0, items.findIndex((item) => item.current));
-  return {
-    items() {
-      return items;
-    },
-    selectedIndex() {
-      return selected;
-    },
-    selectedModel() {
-      return items[selected] || null;
-    },
-    handleKey(key = {}) {
-      if (!items.length) {
-        return false;
-      }
-      if (key.name === "up") {
-        selected = selected <= 0 ? items.length - 1 : selected - 1;
-        return true;
-      }
-      if (key.name === "down") {
-        selected = selected >= items.length - 1 ? 0 : selected + 1;
-        return true;
-      }
-      return false;
-    },
-  };
-}
-
-function normalizeModels(models, currentModel) {
-  const current = String(currentModel || "").trim();
-  const seen = new Set();
-  const items = [];
-  let currentFound = false;
-  for (const model of Array.isArray(models) ? models : []) {
-    const name = String(model || "").trim();
-    if (!name || seen.has(name)) {
-      continue;
-    }
-    seen.add(name);
-    const isCurrent = name === current;
-    currentFound ||= isCurrent;
-    items.push({ name, current: isCurrent });
-  }
-  if (current && !currentFound) {
-    items.unshift({ name: current, current: true });
-  }
-  return items;
-}
+export function createModelMenuState(models, currentModel = "") {
+  const items = normalizeModels(models, currentModel);
+  let selected = Math.max(0, items.findIndex((item) => item.current));
+  return {
+    items() {
+      return items;
+    },
+    selectedIndex() {
+      return selected;
+    },
+    selectedModel() {
+      return items[selected] || null;
+    },
+    handleKey(key = {}) {
+      if (!items.length) {
+        return false;
+      }
+      if (key.name === "up") {
+        selected = selected <= 0 ? items.length - 1 : selected - 1;
+        return true;
+      }
+      if (key.name === "down") {
+        selected = selected >= items.length - 1 ? 0 : selected + 1;
+        return true;
+      }
+      return false;
+    },
+  };
+}
+
+function normalizeModels(models, currentModel) {
+  const current = String(currentModel || "").trim();
+  const seen = new Set();
+  const items = [];
+  let currentFound = false;
+  for (const model of Array.isArray(models) ? models : []) {
+    const name = String(model || "").trim();
+    if (!name || seen.has(name)) {
+      continue;
+    }
+    seen.add(name);
+    const isCurrent = name === current;
+    currentFound ||= isCurrent;
+    items.push({ name, current: isCurrent });
+  }
+  if (current && !currentFound) {
+    items.unshift({ name: current, current: true });
+  }
+  return items;
+}

package/lib/one-shot-progress.js

@@ -0,0 +1,145 @@
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const SPINNER_INTERVAL_MS = 120;
+const NAME_COLUMN_MAX = 26;
+
+export function formatDuration(ms) {
+  const value = Math.max(0, Number(ms) || 0);
+  if (value < 1000) return `${Math.round(value)}ms`;
+  if (value < 60_000) return `${(value / 1000).toFixed(1)}s`;
+  return `${Math.floor(value / 60_000)}m ${Math.round((value % 60_000) / 1000)}s`;
+}
+
+export function createOneShotProgress({ stderr, stream = null } = {}) {
+  const tty = stream ?? { isTTY: false };
+  const isTTY = Boolean(tty.isTTY);
+  const useColor = isTTY && process.env.NO_COLOR === undefined;
+  const c = useColor
+    ? { dim: "\x1b[2m", red: "\x1b[31m", green: "\x1b[32m", reset: "\x1b[0m" }
+    : { dim: "", red: "", green: "", reset: "" };
+
+  const tools = new Map();
+  let toolCounter = 0;
+  let printedToolLines = 0;
+  let lastPendingToolId = null;
+  let spinnerTimer = null;
+  let spinnerFrame = 0;
+  let spinnerLabel = "";
+  let active = false;
+
+  function emit(text) {
+    stopSpinner();
+    stderr(text);
+  }
+
+  function startSpinner(label) {
+    spinnerLabel = label;
+    if (!isTTY || spinnerTimer) return;
+    spinnerFrame = 0;
+    renderSpinner();
+    spinnerTimer = setInterval(() => {
+      spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES.length;
+      renderSpinner();
+    }, SPINNER_INTERVAL_MS);
+    spinnerTimer.unref?.();
+  }
+
+  function renderSpinner() {
+    stderr(`\r${c.dim}${SPINNER_FRAMES[spinnerFrame]} ${spinnerLabel}${c.reset}\x1b[K`);
+  }
+
+  function stopSpinner() {
+    if (!spinnerTimer) return;
+    clearInterval(spinnerTimer);
+    spinnerTimer = null;
+    if (isTTY) stderr("\r\x1b[K");
+  }
+
+  function resumeSpinner() {
+    if (active && isTTY && spinnerLabel) startSpinner(spinnerLabel);
+  }
+
+  function toolLine(entry) {
+    const index = String(entry.index).padStart(2, " ");
+    const truncated = entry.name.length > NAME_COLUMN_MAX
+      ? `${entry.name.slice(0, NAME_COLUMN_MAX - 1)}…`
+      : entry.name;
+    if (entry.finishedAt === null) {
+      const pendingMark = isTTY ? `  ${c.dim}…${c.reset}` : "";
+      return `  ${c.dim}${index}${c.reset}  ${truncated}${pendingMark}`;
+    }
+    const duration = c.dim + formatDuration(entry.durationMs) + c.reset;
+    const mark = entry.ok ? "" : ` ${c.red}✗${c.reset}`;
+    return `  ${c.dim}${index}${c.reset}  ${truncated}  ${duration}${mark}`;
+  }
+
+  return {
+    begin() {
+      active = true;
+      startSpinner("starting runtime");
+    },
+
+    hasTool(toolCallId) {
+      return tools.has(toolCallId);
+    },
+
+    get toolCount() {
+      return tools.size;
+    },
+
+    session({ sessionId, model, baseUrl }) {
+      const parts = [`session ${sessionId}`];
+      if (model) parts.push(`model ${model}`);
+      if (baseUrl) parts.push(`api ${baseUrl}`);
+      emit(`${c.dim}·${c.reset} ${parts.join(`${c.dim} · ${c.reset}`)}\n`);
+      startSpinner("working");
+    },
+
+    note(text) {
+      emit(`${c.dim}· ${text}${c.reset}\n`);
+      resumeSpinner();
+    },
+
+    toolStarted(toolCallId, toolName) {
+      const name = toolName || "tool";
+      toolCounter += 1;
+      const entry = { index: toolCounter, name, finishedAt: null, durationMs: 0, ok: true };
+      tools.set(toolCallId, entry);
+      emit(`${toolLine(entry)}\n`);
+      printedToolLines += 1;
+      lastPendingToolId = toolCallId;
+      resumeSpinner();
+    },
+
+    toolFinished(toolCallId, { ok, durationMs }) {
+      const entry = tools.get(toolCallId);
+      if (!entry || entry.finishedAt !== null) return;
+      entry.finishedAt = Date.now();
+      entry.durationMs = Number(durationMs) || 0;
+      entry.ok = Boolean(ok);
+      const canRewrite = isTTY && toolCallId === lastPendingToolId;
+      if (canRewrite) {
+        stopSpinner();
+        stderr(`\x1b[1A\r\x1b[K${toolLine(entry)}\n`);
+        lastPendingToolId = null;
+        resumeSpinner();
+        return;
+      }
+      if (!entry.ok) {
+        emit(`  ${c.red}↳ ${entry.name} failed${c.reset} ${c.dim}${formatDuration(entry.durationMs)}${c.reset}\n`);
+        resumeSpinner();
+      }
+      if (toolCallId === lastPendingToolId) lastPendingToolId = null;
+    },
+
+    done(elapsedMs) {
+      active = false;
+      if (printedToolLines > 0) emit("\n");
+      emit(`${c.green}✓${c.reset} done in ${formatDuration(elapsedMs)}\n`);
+    },
+
+    fail(message) {
+      active = false;
+      emit(`${c.red}✗ ${message}${c.reset}\n`);
+    },
+  };
+}