@ww_nero/mini-cli 1.0.56

package/src/utils/commands.js

@@ -0,0 +1,89 @@
+const chalk = require('chalk');
+
+const SLASH_COMMANDS = [
+  { key: 'model', value: '/model', description: '查看或切换模型' },
+  { key: 'clear', value: '/clear', description: '清空上下文' },
+  { key: 'resume', value: '/resume', description: '查看或恢复历史会话' },
+  { key: 'exit', value: '/exit', description: '退出对话' }
+];
+
+const getSlashCommandListText = () => SLASH_COMMANDS.map((entry) => entry.value).join('、');
+
+const createCommandHandler = ({ modelManager, resetMessages, closeSession, handleResume }) => {
+  const handleClearCommand = () => {
+    resetMessages();
+    console.log(chalk.green('已清空上下文。'));
+  };
+
+  const handleModelCommand = (rawArgs = '') => {
+    const args = rawArgs.trim();
+    if (!args || ['list', 'ls'].includes(args.toLowerCase())) {
+      modelManager.listModels();
+      return;
+    }
+
+    const numeric = Number.parseInt(args, 10);
+    if (!Number.isNaN(numeric) && String(numeric) === args) {
+      const index = numeric - 1;
+      if (!modelManager.setActiveModel(index, { updateDefault: true, announce: true })) {
+        console.error(chalk.red(`序号 ${args} 不在 1-${modelManager.getTotalModels()} 范围内，已保持 ${modelManager.getDefaultModelDescription()}。`));
+        modelManager.resetToDefault();
+      }
+      return;
+    }
+
+    modelManager.applyModelByName(args, { source: 'command', announceSuccess: true, showError: true });
+  };
+
+  const handleResumeCommand = (rawArgs = '') => {
+    if (typeof handleResume === 'function') {
+      handleResume(rawArgs);
+    } else {
+      console.log(chalk.yellow('当前构建未启用历史记录功能。'));
+    }
+  };
+
+  const handleSlashCommand = (raw = '') => {
+    if (!raw.startsWith('/')) {
+      return { handled: false, shouldExit: false };
+    }
+    const trimmed = raw.slice(1).trim();
+    const availableCommandsText = getSlashCommandListText() || '/model、/clear、/exit';
+    if (!trimmed) {
+      console.log(chalk.yellow(`请输入完整命令，例如 ${availableCommandsText}。`));
+      return { handled: true, shouldExit: false };
+    }
+    const [command] = trimmed.split(' ');
+    const args = trimmed.slice(command.length).trim();
+    switch ((command || '').toLowerCase()) {
+      case 'model':
+        handleModelCommand(args);
+        return { handled: true, shouldExit: false };
+      case 'clear':
+        handleClearCommand();
+        return { handled: true, shouldExit: false };
+      case 'resume':
+        handleResumeCommand(args);
+        return { handled: true, shouldExit: false };
+      case 'exit':
+        closeSession();
+        return { handled: true, shouldExit: true };
+      default:
+        console.log(chalk.yellow(`未识别的命令 /${command}，可用命令：${availableCommandsText}。`));
+        return { handled: true, shouldExit: false };
+    }
+  };
+
+  return {
+    handleSlashCommand,
+    handleClearCommand,
+    handleModelCommand,
+    handleResumeCommand
+  };
+};
+
+module.exports = {
+  SLASH_COMMANDS,
+  getSlashCommandListText,
+  createCommandHandler
+};

package/src/utils/git.js

@@ -0,0 +1,89 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+
+const DEFAULT_GITIGNORE_ENTRIES = [
+  'venv',
+  'node_modules',
+  'logs',
+  'build',
+  'coverage',
+  '*.log',
+  '*.tmp',
+  '*.temp',
+  '*.DS_Store',
+  'Thumbs.db',
+  'package-lock.json',
+  'dist',
+  '.idea',
+  '*.pyc'
+];
+
+const ensureGitRepository = (workspaceRoot) => {
+  if (!workspaceRoot) {
+    return { gitInitialized: false, gitignoreCreated: false };
+  }
+
+  const gitDirPath = path.join(workspaceRoot, '.git');
+  const gitignorePath = path.join(workspaceRoot, '.gitignore');
+  let gitInitialized = false;
+  let gitignoreCreated = false;
+  let initialCommitCreated = false;
+
+  if (!fs.existsSync(gitDirPath)) {
+    try {
+      execSync('git init', { cwd: workspaceRoot, stdio: 'ignore' });
+      gitInitialized = true;
+    } catch (error) {
+      console.log(chalk.yellow(`自动初始化 Git 仓库失败：${error.message}`));
+    }
+  }
+
+  if (!fs.existsSync(gitignorePath)) {
+    try {
+      const content = DEFAULT_GITIGNORE_ENTRIES.join('\n') + '\n';
+      fs.writeFileSync(gitignorePath, content, 'utf8');
+      gitignoreCreated = true;
+    } catch (error) {
+      console.log(chalk.yellow(`创建 .gitignore 失败：${error.message}`));
+    }
+  }
+
+  // 如果完成了 git init 或 .gitignore 创建，检查是否需要初始提交
+  if ((gitInitialized || gitignoreCreated) && fs.existsSync(gitDirPath)) {
+    try {
+      // 检查是否有任何提交
+      const hasCommits = (() => {
+        try {
+          execSync('git rev-parse HEAD', { cwd: workspaceRoot, stdio: 'ignore' });
+          return true;
+        } catch (_) {
+          return false;
+        }
+      })();
+
+      if (!hasCommits) {
+        // 添加所有文件并创建初始提交
+        execSync('git add .', { cwd: workspaceRoot, stdio: 'ignore' });
+        execSync('git commit -m "init project"', { cwd: workspaceRoot, stdio: 'ignore' });
+        initialCommitCreated = true;
+      }
+    } catch (error) {
+      console.log(chalk.yellow(`创建初始提交失败：${error.message}`));
+    }
+  }
+
+  return {
+    gitInitialized,
+    gitignoreCreated,
+    initialCommitCreated,
+    gitignorePath,
+    gitDirPath
+  };
+};
+
+module.exports = {
+  ensureGitRepository,
+  DEFAULT_GITIGNORE_ENTRIES
+};

package/src/utils/helpers.js

@@ -0,0 +1,93 @@
+const fsPromises = require('fs/promises');
+const path = require('path');
+
+const normalizeLineBreaks = (text = '') => {
+  if (!text) return '';
+  const normalized = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+  return /^\n*$/.test(normalized) ? '' : normalized;
+};
+
+const resolveWorkspacePath = (workspaceRoot, targetPath = '.', options = {}) => {
+  if (!workspaceRoot) {
+    throw new Error('未找到工作区目录');
+  }
+  const base = path.resolve(workspaceRoot);
+  const resolved = path.resolve(base, targetPath || '.');
+  const relative = path.relative(base, resolved);
+  if (relative.startsWith('..') || path.isAbsolute(relative)) {
+    throw new Error('路径必须位于当前工作区内');
+  }
+
+  if (!options.allowGit) {
+    const segments = relative.split(path.sep).filter(Boolean);
+    if (segments.includes('.git')) {
+      throw new Error('不允许操作 .git 目录');
+    }
+  }
+
+  return resolved;
+};
+
+const ensureDirectory = async (filePath) => {
+  const dir = path.dirname(filePath);
+  await fsPromises.mkdir(dir, { recursive: true });
+};
+
+const readTextFile = async (filePath) => {
+  try {
+    return await fsPromises.readFile(filePath, 'utf8');
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      throw new Error('文件不存在');
+    }
+    throw error;
+  }
+};
+
+const writeTextFile = async (filePath, content) => {
+  await ensureDirectory(filePath);
+  await fsPromises.writeFile(filePath, content, 'utf8');
+};
+
+const isCodeIdentical = (prev, next) => {
+  return normalizeLineBreaks(prev) === normalizeLineBreaks(next);
+};
+
+const processContent = (content) => {
+  if (!content) return '';
+  let processed = content.replace(/\r/g, '\n');
+  processed = processed
+    .split('\n')
+    .map(line => (line.trim() === '' ? '' : line))
+    .join('\n');
+  processed = processed.replace(/^\n+|\n+$/g, '');
+  processed = processed.replace(/\n{3,}/g, '\n\n');
+  return processed + '\n';
+};
+
+const safeJsonParse = (text) => {
+  if (!text || typeof text !== 'string') return null;
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    try {
+      const parts = text.split('}{');
+      if (parts.length > 1) {
+        return JSON.parse(parts[0] + '}');
+      }
+    } catch (_) {
+      // ignore secondary error
+    }
+    return null;
+  }
+};
+
+module.exports = {
+  normalizeLineBreaks,
+  resolveWorkspacePath,
+  readTextFile,
+  writeTextFile,
+  isCodeIdentical,
+  processContent,
+  safeJsonParse
+};

package/src/utils/history.js

@@ -0,0 +1,181 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+
+const MAX_HISTORY_RECORDS = 50;
+const HISTORY_BASE_DIR = path.join(os.homedir(), '.mini', 'cli');
+const HISTORY_FILENAME_PATTERN = /^\d{14}\.json$/;
+
+const resolveProjectPath = (projectPath) => path.resolve(projectPath || process.cwd());
+
+const getProjectMd5 = (projectPath) => (
+  crypto
+    .createHash('md5')
+    .update(resolveProjectPath(projectPath), 'utf8')
+    .digest('hex')
+);
+
+const getProjectHistoryDir = (projectPath) => path.join(HISTORY_BASE_DIR, getProjectMd5(projectPath));
+
+const ensureHistoryDir = (projectPath) => {
+  const dir = getProjectHistoryDir(projectPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+};
+
+const pad = (value, length = 2) => String(value).padStart(length, '0');
+
+const formatTimestamp = (date = new Date()) => {
+  const year = date.getFullYear();
+  const month = pad(date.getMonth() + 1);
+  const day = pad(date.getDate());
+  const hour = pad(date.getHours());
+  const minute = pad(date.getMinutes());
+  const second = pad(date.getSeconds());
+  return `${year}${month}${day}${hour}${minute}${second}`;
+};
+
+const createHistoryFilePath = (projectPath) => {
+  const historyDir = ensureHistoryDir(projectPath);
+  let attempt = new Date();
+  const maxAttempts = 120;
+
+  for (let i = 0; i < maxAttempts; i += 1) {
+    const name = `${formatTimestamp(attempt)}.json`;
+    const filePath = path.join(historyDir, name);
+    if (!fs.existsSync(filePath)) {
+      return filePath;
+    }
+    attempt = new Date(attempt.getTime() + 1000);
+  }
+
+  throw new Error('无法生成唯一的历史记录文件名');
+};
+
+const normalizeMessagesPayload = (payload) => {
+  if (Array.isArray(payload)) {
+    return payload;
+  }
+  if (payload && typeof payload === 'object' && Array.isArray(payload.messages)) {
+    return payload.messages;
+  }
+  return null;
+};
+
+const saveHistoryMessages = (filePath, messages) => {
+  if (!filePath || !Array.isArray(messages)) {
+    return false;
+  }
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, `${JSON.stringify(messages, null, 2)}\n`, 'utf8');
+  return true;
+};
+
+const readHistoryMessages = (filePath) => {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return normalizeMessagesPayload(JSON.parse(raw));
+  } catch (error) {
+    return null;
+  }
+};
+
+const listHistoryFiles = (projectPath) => {
+  const historyDir = ensureHistoryDir(projectPath);
+  try {
+    const entries = fs.readdirSync(historyDir, { withFileTypes: true });
+    return entries
+      .filter((entry) => entry.isFile() && HISTORY_FILENAME_PATTERN.test(entry.name))
+      .sort((a, b) => b.name.localeCompare(a.name))
+      .map((entry) => ({
+        name: entry.name,
+        filePath: path.join(historyDir, entry.name)
+      }));
+  } catch (error) {
+    return [];
+  }
+};
+
+const trimHistoryFiles = (maxEntries = MAX_HISTORY_RECORDS, projectPath) => {
+  if (!Number.isFinite(maxEntries) || maxEntries <= 0) {
+    return [];
+  }
+  const files = listHistoryFiles(projectPath);
+  if (files.length <= maxEntries) {
+    return [];
+  }
+  const toRemove = files.slice(maxEntries);
+  toRemove.forEach((entry) => {
+    try {
+      fs.unlinkSync(entry.filePath);
+    } catch (error) {
+      // ignore deletion errors
+    }
+  });
+  return toRemove.map((entry) => entry.filePath);
+};
+
+const refreshHistoryFilePath = (filePath, projectPath) => {
+  if (!filePath || typeof filePath !== 'string') {
+    return null;
+  }
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  const dir = ensureHistoryDir(projectPath);
+  if (path.dirname(filePath) !== dir) {
+    return filePath;
+  }
+  try {
+    const nextPath = createHistoryFilePath(projectPath);
+    fs.renameSync(filePath, nextPath);
+    return nextPath;
+  } catch (error) {
+    return filePath;
+  }
+};
+
+const extractFirstUserQuestion = (messages) => {
+  if (!Array.isArray(messages)) {
+    return '';
+  }
+  const firstUserMessage = messages.find((msg) => msg && msg.role === 'user');
+  const text = firstUserMessage && typeof firstUserMessage.content === 'string'
+    ? firstUserMessage.content.trim()
+    : '';
+  return text;
+};
+
+const formatPreviewText = (text, maxLength = 20) => {
+  if (!text) {
+    return '(空问题)';
+  }
+  const normalized = text.replace(/\s+/g, ' ').trim();
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.slice(0, maxLength)}...`;
+};
+
+module.exports = {
+  HISTORY_BASE_DIR,
+  MAX_HISTORY_RECORDS,
+  getProjectMd5,
+  getProjectHistoryDir,
+  ensureHistoryDir,
+  createHistoryFilePath,
+  saveHistoryMessages,
+  readHistoryMessages,
+  listHistoryFiles,
+  trimHistoryFiles,
+  refreshHistoryFilePath,
+  extractFirstUserQuestion,
+  formatPreviewText,
+  formatTimestamp
+};

package/src/utils/model.js

@@ -0,0 +1,127 @@
+const chalk = require('chalk');
+const { promoteEndpointInConfig } = require('../config');
+
+const describeModel = (endpoint) => {
+  if (!endpoint) {
+    return '未知模型';
+  }
+  const alias = typeof endpoint.name === 'string' ? endpoint.name.trim() : '';
+  const label = alias || endpoint.model;
+  if (alias && alias !== endpoint.model) {
+    return `${label} (${endpoint.model})`;
+  }
+  return label;
+};
+
+const normalizeModelInput = (value = '') => {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return '';
+  }
+  const quote = trimmed[0];
+  if ((quote === '"' || quote === '\'') && trimmed.endsWith(quote) && trimmed.length > 1) {
+    return trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+};
+
+const findModelIndexByName = (endpoints, name = '') => {
+  const normalized = name.toLowerCase();
+  return endpoints.findIndex((endpoint) => {
+    const candidates = [endpoint.name, endpoint.model];
+    return candidates.some((candidate) => typeof candidate === 'string' && candidate.toLowerCase() === normalized);
+  });
+};
+
+const createModelManager = (endpoints, { configPath } = {}) => {
+  let defaultEndpointIndex = 0;
+  let activeEndpointIndex = 0;
+
+  const getActiveEndpoint = () => endpoints[activeEndpointIndex];
+  const getDefaultEndpoint = () => endpoints[defaultEndpointIndex];
+  const getTotalModels = () => endpoints.length;
+  const getDefaultModelDescription = () => describeModel(getDefaultEndpoint());
+
+  const resetToDefault = () => {
+    setActiveModel(defaultEndpointIndex, { updateDefault: false, announce: false, persistConfig: false });
+  };
+
+  const setActiveModel = (
+    index,
+    { updateDefault = false, announce = true, announcePrefix = '已切换至', reason = '', persistConfig = true } = {}
+  ) => {
+    if (index < 0 || index >= endpoints.length) {
+      return false;
+    }
+    activeEndpointIndex = index;
+    if (updateDefault) {
+      defaultEndpointIndex = index;
+      if (persistConfig && configPath) {
+        const endpoint = endpoints[index];
+        if (endpoint && endpoint.signature) {
+          promoteEndpointInConfig(configPath, endpoint.signature);
+        }
+      }
+    }
+    if (announce) {
+      console.log(chalk.green(`${announcePrefix}模型 ${describeModel(endpoints[index])}`));
+      if (reason) {
+        console.log(chalk.gray(reason));
+      }
+    }
+    return true;
+  };
+
+  const applyModelByName = (rawName, { source = 'command', announceSuccess = true, showError = true } = {}) => {
+    const normalizedInput = normalizeModelInput(rawName || '');
+    if (!normalizedInput) {
+      if (showError) {
+        console.log(chalk.yellow('请输入要切换的模型名称。'));
+      }
+      return false;
+    }
+    const index = findModelIndexByName(endpoints, normalizedInput);
+    if (index === -1) {
+      if (showError) {
+        console.error(chalk.red(`未找到模型 ${normalizedInput}，已保持 ${describeModel(getDefaultEndpoint())}。`));
+      }
+      setActiveModel(defaultEndpointIndex, { updateDefault: false, announce: false, persistConfig: false });
+      return false;
+    }
+    const announcePrefix = source === 'cli' ? '已应用启动' : '已切换至';
+    setActiveModel(index, { updateDefault: true, announce: announceSuccess, announcePrefix });
+    return true;
+  };
+
+  const listModels = () => {
+    console.log(chalk.gray('可用模型列表：'));
+    endpoints.forEach((endpoint, idx) => {
+      const markers = [];
+      if (idx === activeEndpointIndex) {
+        markers.push(chalk.green('当前'));
+      }
+      if (idx === defaultEndpointIndex) {
+        markers.push(chalk.cyan('默认'));
+      }
+      const markerText = markers.length > 0 ? ` [${markers.join('/')}]` : '';
+      console.log(`  ${idx + 1}. ${describeModel(endpoint)}${markerText}`);
+    });
+    console.log(chalk.gray('使用 /model <名称|序号> 切换模型。'));
+  };
+
+  return {
+    getActiveEndpoint,
+    getDefaultEndpoint,
+    getTotalModels,
+    getDefaultModelDescription,
+    resetToDefault,
+    setActiveModel,
+    applyModelByName,
+    listModels
+  };
+};
+
+module.exports = {
+  describeModel,
+  createModelManager
+};

package/src/utils/output.js

@@ -0,0 +1,76 @@
+const chalk = require('chalk');
+const { splitThinkContent, summarizeReasoning } = require('./think');
+
+const mergeReasoningContent = (...segments) => {
+  const normalized = segments
+    .map((segment) => (typeof segment === 'string' ? segment.trim() : ''))
+    .filter(Boolean);
+  if (normalized.length === 0) {
+    return '';
+  }
+  return normalized.join('\n');
+};
+
+const printReasoningSummary = (text, ensureNewline) => {
+  if (!text) return;
+  ensureNewline();
+  console.log(chalk.gray(`思考：${summarizeReasoning(text)}`));
+};
+
+const printAssistantContent = (text, ensureNewline) => {
+  if (typeof text !== 'string' || !text) {
+    return;
+  }
+  ensureNewline();
+  const output = chalk.blue(text);
+  process.stdout.write(output);
+  if (!text.endsWith('\n')) {
+    process.stdout.write('\n');
+  }
+};
+
+const renderAssistantOutput = (reasoning, content, ensureNewline) => {
+  printReasoningSummary(reasoning, ensureNewline);
+  printAssistantContent(content, ensureNewline);
+};
+
+const sanitizeContentWithThink = (primary = '', fallback = '') => {
+  const normalizedPrimary = typeof primary === 'string' ? primary.trim() : '';
+  if (normalizedPrimary) {
+    return normalizedPrimary;
+  }
+  if (typeof fallback !== 'string' || !fallback.trim()) {
+    return '';
+  }
+  const { content } = splitThinkContent(fallback);
+  return (content || '').trim();
+};
+
+const formatTokensToK = (totalTokens) => {
+  if (typeof totalTokens !== 'number' || Number.isNaN(totalTokens)) {
+    return null;
+  }
+  return `${(totalTokens / 1000).toFixed(1)}k`;
+};
+
+const printUsageTokens = (usage) => {
+  if (!usage || typeof usage !== 'object') {
+    return;
+  }
+  const totalTokens = usage.total_tokens;
+  const formatted = formatTokensToK(totalTokens);
+  if (!formatted) {
+    return;
+  }
+  const colorFn = typeof chalk.hex === 'function' ? chalk.hex('#9A32CD') : chalk.magenta;
+  console.log(colorFn(`已使用tokens: ${formatted}`));
+};
+
+module.exports = {
+  mergeReasoningContent,
+  printReasoningSummary,
+  printAssistantContent,
+  renderAssistantOutput,
+  sanitizeContentWithThink,
+  printUsageTokens
+};