@ww_nero/mini-cli 1.0.56

package/src/utils/renderer.js

@@ -0,0 +1,92 @@
+const chalk = require('chalk');
+
+const ORANGE = typeof chalk.hex === 'function'
+  ? chalk.hex('#FFA500')
+  : chalk.keyword('orange');
+
+const truncateText = (text, maxLength = 200) => {
+  if (!text || typeof text !== 'string') {
+    return text;
+  }
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.substring(0, maxLength) + '...';
+};
+
+const formatWriteLineCountTag = (args = {}) => {
+  if (!args || typeof args.content !== 'string') {
+    return ORANGE('(0)');
+  }
+  const normalized = args.content.replace(/\r/g, '');
+  if (!normalized) {
+    return ORANGE('(0)');
+  }
+  const newlineMatches = normalized.match(/\n/g);
+  const newlineCount = Array.isArray(newlineMatches) ? newlineMatches.length : 0;
+  const endsWithNewline = normalized.endsWith('\n');
+  const lineCount = endsWithNewline ? newlineCount : newlineCount + 1;
+  return ORANGE(`(${lineCount})`);
+};
+
+const formatHeader = (name, args, options = {}) => {
+  const statusTag = options.statusTag || '';
+  const extraMeta = Array.isArray(options.extraMeta) ? options.extraMeta : [];
+  const labelBase = `${chalk.yellow('🔧')} ${chalk.yellow(name)}`;
+  const writeTag = name === 'write_file' ? formatWriteLineCountTag(args) : '';
+  const labelWithWriteInfo = `${labelBase}${writeTag}`;
+  const label = statusTag ? `${labelWithWriteInfo}${statusTag}` : labelWithWriteInfo;
+  const metaParts = [...extraMeta];
+
+  if (name === 'execute_bash') {
+    if (args.command) metaParts.push(`command="${truncateText(args.command)}"`);
+    if (args.workingDirectory && args.workingDirectory !== '.') {
+      metaParts.push(`dir=${args.workingDirectory}`);
+    }
+  } else if (['read_file', 'write_file', 'search_and_replace'].includes(name)) {
+    if (args.filePath) metaParts.push(args.filePath);
+  } else if (name === 'write_todos') {
+    const count = Array.isArray(args.todos) ? args.todos.length : 0;
+    metaParts.push(`${count} items`);
+  } else if (name === 'convert') {
+    if (typeof args.input === 'string') {
+      metaParts.push(`input=${truncateText(args.input, 160)}`);
+    } else if (Array.isArray(args.input)) {
+      metaParts.push(`input=${truncateText(args.input.join(', '), 160)}`);
+    }
+    if (args.output) {
+      metaParts.push(`output=${truncateText(String(args.output), 160)}`);
+    }
+  }
+
+  const meta = metaParts.length > 0 ? ` (${metaParts.join(', ')})` : '';
+  return `${label}${meta}`;
+};
+
+const safeStringify = (value) => {
+  try {
+    return JSON.stringify(value);
+  } catch (_) {
+    return String(value);
+  }
+};
+
+const compactText = (text) => String(text || '').replace(/\s+/g, ' ').trim();
+
+const renderToolCall = ({ functionName, args = {} }, mcpToolNames = new Set()) => {
+  const isMcpTool = mcpToolNames.has(functionName);
+
+  const extraMeta = [];
+  if (isMcpTool) {
+    const argsPreview = truncateText(compactText(safeStringify(args) || ''), 200);
+    if (argsPreview) {
+      extraMeta.push(argsPreview);
+    }
+  }
+
+  console.log(formatHeader(functionName, args, { extraMeta }));
+};
+
+module.exports = {
+  renderToolCall
+};

package/src/utils/settings.js

@@ -0,0 +1,90 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const MINI_DIR_NAME = '.mini';
+const SETTINGS_FILE_NAME = 'settings.json';
+const DEFAULT_TOOL_OUTPUT_TOKEN_LIMIT = 32768;
+const DEFAULT_ALLOWED_COMMANDS = [
+  'rm', 'rmdir', 'touch', 'mkdir', 'cd', 'cp', 'mv', 'node', 'npm', 'ls',
+  'grep', 'cat', 'echo', 'sed', 'head', 'tail', 'find', 'true', 'false',
+  'pkill', 'kill', 'curl', 'ps', 'lsof', 'git', 'pip', 'python', 'pandoc'
+];
+
+const ensureArrayOfStrings = (value, fallback = []) => {
+  if (!Array.isArray(value)) {
+    return [...fallback];
+  }
+  return value.map(String).filter(Boolean);
+};
+
+const loadSettings = ({ defaultTools = [] } = {}) => {
+  const settingsPath = path.join(os.homedir(), MINI_DIR_NAME, SETTINGS_FILE_NAME);
+  const dir = path.dirname(settingsPath);
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  const defaultSettings = {
+    mcps: [],
+    tools: [...defaultTools],
+    toolOutputTokenLimit: DEFAULT_TOOL_OUTPUT_TOKEN_LIMIT,
+    allowedCommands: [...DEFAULT_ALLOWED_COMMANDS]
+  };
+
+  let parsed = null;
+  let created = false;
+  let needsUpdate = false;
+
+  if (!fs.existsSync(settingsPath)) {
+    fs.writeFileSync(settingsPath, `${JSON.stringify(defaultSettings, null, 2)}\n`, 'utf8');
+    parsed = defaultSettings;
+    created = true;
+  } else {
+    try {
+      const raw = fs.readFileSync(settingsPath, 'utf8') || '{}';
+      parsed = JSON.parse(raw);
+
+      if (typeof parsed.toolOutputTokenLimit !== 'number') {
+        parsed.toolOutputTokenLimit = DEFAULT_TOOL_OUTPUT_TOKEN_LIMIT;
+        needsUpdate = true;
+      }
+
+      if (!Array.isArray(parsed.allowedCommands)) {
+        parsed.allowedCommands = [...DEFAULT_ALLOWED_COMMANDS];
+        needsUpdate = true;
+      }
+    } catch (error) {
+      parsed = defaultSettings;
+    }
+  }
+
+  const settings = {
+    mcps: ensureArrayOfStrings(parsed.mcps, defaultSettings.mcps),
+    tools: ensureArrayOfStrings(parsed.tools, defaultSettings.tools),
+    toolOutputTokenLimit: typeof parsed.toolOutputTokenLimit === 'number' && parsed.toolOutputTokenLimit > 0
+      ? parsed.toolOutputTokenLimit
+      : DEFAULT_TOOL_OUTPUT_TOKEN_LIMIT,
+    allowedCommands: ensureArrayOfStrings(parsed.allowedCommands, DEFAULT_ALLOWED_COMMANDS)
+  };
+
+  if (needsUpdate) {
+    try {
+      fs.writeFileSync(settingsPath, `${JSON.stringify(parsed, null, 2)}\n`, 'utf8');
+    } catch (error) {
+    }
+  }
+
+  return {
+    settingsPath,
+    settings,
+    created
+  };
+};
+
+module.exports = {
+  loadSettings,
+  DEFAULT_TOOL_OUTPUT_TOKEN_LIMIT,
+  DEFAULT_ALLOWED_COMMANDS
+};

package/src/utils/think.js

@@ -0,0 +1,211 @@
+const THINK_TAGS = [
+  { name: 'think', open: '<think>', close: '</think>' },
+  { name: 'tihinking', open: '<tihinking>', close: '</tihinking>' },
+  { name: 'thought', open: '<thought>', close: '</thought>' }
+];
+
+const THINK_TAG_MAP = new Map(
+  THINK_TAGS.map(tag => [tag.name.toLowerCase(), { ...tag, closeLower: tag.close.toLowerCase() }])
+);
+
+const findTagEnd = (text, startIndex) => {
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+
+  for (let i = startIndex; i < text.length; i++) {
+    const char = text[i];
+
+    if (char === '\'' && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+
+    if (char === '>' && !inSingleQuote && !inDoubleQuote) {
+      return i;
+    }
+  }
+
+  return -1;
+};
+
+const parseTagInfo = (tagText) => {
+  if (!tagText.startsWith('<') || !tagText.endsWith('>')) return null;
+
+  let inner = tagText.slice(1, -1).trim();
+  if (!inner) return null;
+
+  let type = 'start';
+  if (inner.startsWith('/')) {
+    type = 'end';
+    inner = inner.slice(1).trim();
+  } else if (inner.endsWith('/')) {
+    type = 'self';
+    inner = inner.slice(0, -1).trim();
+  }
+
+  const nameMatch = inner.match(/^([a-zA-Z0-9_-]+)/);
+  if (!nameMatch) return null;
+
+  return {
+    type,
+    name: nameMatch[1].toLowerCase()
+  };
+};
+
+const createThinkParserState = () => ({
+  buffer: '',
+  currentThink: null
+});
+
+const processThinkChunk = (state, chunk = '') => {
+  if (!state) {
+    throw new Error('processThinkChunk requires a state object.');
+  }
+
+  if (chunk == null) {
+    chunk = '';
+  }
+
+  if (typeof chunk !== 'string') {
+    chunk = String(chunk);
+  }
+
+  if (!state.buffer) {
+    state.buffer = '';
+  }
+
+  state.buffer += chunk;
+
+  let contentChunk = '';
+  let reasonChunk = '';
+
+  const consumePrefix = (length) => {
+    const prefix = state.buffer.slice(0, length);
+    state.buffer = state.buffer.slice(length);
+    return prefix;
+  };
+
+  while (state.buffer.length > 0) {
+    if (state.currentThink) {
+      const thinkInfo = THINK_TAG_MAP.get(state.currentThink);
+      if (!thinkInfo) {
+        state.currentThink = null;
+        continue;
+      }
+
+      const bufferLower = state.buffer.toLowerCase();
+      const closeIndex = bufferLower.indexOf(thinkInfo.closeLower);
+
+      if (closeIndex === -1) {
+        reasonChunk += consumePrefix(state.buffer.length);
+        return { contentChunk, reasonChunk };
+      }
+
+      reasonChunk += consumePrefix(closeIndex);
+      consumePrefix(thinkInfo.close.length);
+      state.currentThink = null;
+      continue;
+    }
+
+    const nextLt = state.buffer.indexOf('<');
+
+    if (nextLt === -1) {
+      contentChunk += consumePrefix(state.buffer.length);
+      break;
+    }
+
+    if (nextLt > 0) {
+      contentChunk += consumePrefix(nextLt);
+      continue;
+    }
+
+    const tagEnd = findTagEnd(state.buffer, 1);
+    if (tagEnd === -1) {
+      break;
+    }
+
+    const rawTag = consumePrefix(tagEnd + 1);
+    const tagInfo = parseTagInfo(rawTag);
+
+    if (!tagInfo) {
+      contentChunk += rawTag;
+      continue;
+    }
+
+    if (tagInfo.type === 'start') {
+      if (THINK_TAG_MAP.has(tagInfo.name)) {
+        state.currentThink = tagInfo.name;
+        continue;
+      }
+
+      contentChunk += rawTag;
+      continue;
+    }
+
+    if (tagInfo.type === 'end') {
+      contentChunk += rawTag;
+      continue;
+    }
+
+    contentChunk += rawTag;
+  }
+
+  return { contentChunk, reasonChunk };
+};
+
+const flushThinkState = (state) => {
+  if (!state || !state.buffer) {
+    return { contentChunk: '', reasonChunk: '' };
+  }
+
+  const remaining = state.buffer;
+  state.buffer = '';
+
+  if (state.currentThink) {
+    state.currentThink = null;
+    return { contentChunk: '', reasonChunk: remaining };
+  }
+
+  return { contentChunk: remaining, reasonChunk: '' };
+};
+
+const splitThinkContent = (text = '') => {
+  if (!text) {
+    return { content: '', reasoning: '' };
+  }
+
+  const state = createThinkParserState();
+  let content = '';
+  let reasoning = '';
+
+  const result = processThinkChunk(state, text);
+  content += result.contentChunk;
+  reasoning += result.reasonChunk;
+
+  const tail = flushThinkState(state);
+  content += tail.contentChunk;
+  reasoning += tail.reasonChunk;
+
+  return { content, reasoning };
+};
+
+const summarizeReasoning = (text = '') => {
+  if (!text) return '';
+  const normalized = text.replace(/\s+/g, ' ').trim();
+  if (!normalized) return '';
+  return normalized;
+};
+
+module.exports = {
+  THINK_TAGS,
+  createThinkParserState,
+  processThinkChunk,
+  flushThinkState,
+  splitThinkContent,
+  summarizeReasoning
+};