codemini-cli 0.1.1

package/src/core/input-parser.js

@@ -0,0 +1,15 @@
+export function parseInput(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return { type: 'empty' };
+  }
+  if (trimmed.startsWith('!')) {
+    return { type: 'shell', command: trimmed.slice(1).trim() };
+  }
+  if (trimmed.startsWith('/')) {
+    const body = trimmed.slice(1).trim();
+    const [command = '', ...args] = body.split(/\s+/);
+    return { type: 'slash', command, args, full: body };
+  }
+  return { type: 'chat', text: trimmed };
+}

package/src/core/paths.js

@@ -0,0 +1,109 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const APP_DIR = 'codemini-cli';
+const LEGACY_APP_DIR = 'company-coder';
+
+function getPreferredBaseConfigDir() {
+  if (process.env.CODEMINI_CONFIG_DIR) {
+    return process.env.CODEMINI_CONFIG_DIR;
+  }
+
+  if (process.env.COMPANY_CODER_CONFIG_DIR) {
+    return process.env.COMPANY_CODER_CONFIG_DIR;
+  }
+
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+    return path.join(appData, APP_DIR);
+  }
+
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Preferences', APP_DIR);
+  }
+
+  if (process.env.XDG_CONFIG_HOME) {
+    return path.join(process.env.XDG_CONFIG_HOME, APP_DIR);
+  }
+
+  // Fallback for restricted/sandboxed non-Windows environments.
+  return path.join(process.cwd(), '.codemini-cli');
+}
+
+function getLegacyBaseConfigDir() {
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+    return path.join(appData, LEGACY_APP_DIR);
+  }
+
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Preferences', LEGACY_APP_DIR);
+  }
+
+  if (process.env.XDG_CONFIG_HOME) {
+    return path.join(process.env.XDG_CONFIG_HOME, LEGACY_APP_DIR);
+  }
+
+  return path.join(process.cwd(), '.company-coder');
+}
+
+function tryMigrateLegacyDir(preferred, legacy) {
+  if (!preferred || !legacy || preferred === legacy) return preferred;
+  if (fs.existsSync(preferred) || !fs.existsSync(legacy)) return preferred;
+  try {
+    fs.renameSync(legacy, preferred);
+    return preferred;
+  } catch {
+    return preferred;
+  }
+}
+
+export function getBaseConfigDir() {
+  const preferred = getPreferredBaseConfigDir();
+  if (process.env.CODEMINI_CONFIG_DIR || process.env.COMPANY_CODER_CONFIG_DIR) {
+    return preferred;
+  }
+  const legacy = getLegacyBaseConfigDir();
+  return tryMigrateLegacyDir(preferred, legacy);
+}
+
+export function getLegacyConfigDir() {
+  return getLegacyBaseConfigDir();
+}
+
+export function getConfigFilePath() {
+  return path.join(getBaseConfigDir(), 'config.json');
+}
+
+export function getSessionsDir() {
+  return path.join(getBaseConfigDir(), 'sessions');
+}
+
+export function getSkillsDir() {
+  return path.join(getBaseConfigDir(), 'skills');
+}
+
+export function getSkillRegistryPath() {
+  return path.join(getBaseConfigDir(), 'skill-registry.json');
+}
+
+export function getCommandsDir() {
+  return path.join(getBaseConfigDir(), 'commands');
+}
+
+export function getInputHistoryFilePath() {
+  return path.join(getBaseConfigDir(), 'input-history.json');
+}
+
+export function getProjectCommandsDir(cwd = process.cwd()) {
+  return path.join(cwd, '.coder', 'commands');
+}
+
+export function getLegacyProjectSkillsDir(cwd = process.cwd()) {
+  return path.join(cwd, '.coder', 'skills');
+}
+
+export function getLegacyGlobalSkillsDir() {
+  return path.join(getBaseConfigDir(), 'skills');
+}

package/src/core/provider/openai-compatible.js

@@ -0,0 +1,228 @@
+import OpenAI from 'openai';
+
+function extractTextContent(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === 'string') return part;
+        if (part?.type === 'text') return part.text || '';
+        return '';
+      })
+      .join('');
+  }
+  return '';
+}
+
+function emptyToolCall(index) {
+  return {
+    index,
+    id: '',
+    name: '',
+    arguments: ''
+  };
+}
+
+function createClient({ baseUrl, apiKey, timeoutMs, maxRetries }) {
+  return new OpenAI({
+    apiKey,
+    baseURL: baseUrl,
+    timeout: timeoutMs,
+    maxRetries
+  });
+}
+
+function isMiniMaxModel(model) {
+  return String(model || '').toLowerCase().includes('minimax');
+}
+
+function buildPayload({ model, temperature, messages, tools, stream = false }) {
+  const payload = {
+    model,
+    temperature,
+    messages
+  };
+  if (stream) {
+    payload.stream = true;
+  }
+  if (Array.isArray(tools) && tools.length > 0) {
+    payload.tools = tools;
+    payload.tool_choice = 'auto';
+  }
+  if (isMiniMaxModel(model)) {
+    payload.extra_body = { reasoning_split: true };
+  }
+  return payload;
+}
+
+function buildFinalStreamResult(text, toolCallsByIndex, usage) {
+  const toolCalls = Array.from(toolCallsByIndex.entries())
+    .sort((a, b) => a[0] - b[0])
+    .map(([, tc], i) => ({
+      id: tc.id || `tc-${i + 1}`,
+      name: tc.name,
+      arguments: tc.arguments || '{}'
+    }))
+    .filter((tc) => tc.name);
+
+  if (!text && toolCalls.length === 0) {
+    throw new Error('Gateway stream returned empty assistant response');
+  }
+
+  return {
+    text,
+    toolCalls,
+    usage
+  };
+}
+
+function stripMiniMaxThinkContent(text) {
+  const input = String(text || '');
+  if (!input) return '';
+
+  let cursor = 0;
+  let out = '';
+  let removedThink = false;
+
+  while (cursor < input.length) {
+    const openIdx = input.indexOf('<think>', cursor);
+    const closeIdx = input.indexOf('</think>', cursor);
+
+    if (openIdx === -1 && closeIdx === -1) {
+      out += input.slice(cursor);
+      break;
+    }
+
+    if (closeIdx !== -1 && (openIdx === -1 || closeIdx < openIdx)) {
+      removedThink = true;
+      cursor = closeIdx + '</think>'.length;
+      continue;
+    }
+
+    out += input.slice(cursor, openIdx);
+    const closingTagIdx = input.indexOf('</think>', openIdx + '<think>'.length);
+    removedThink = true;
+    if (closingTagIdx === -1) {
+      cursor = input.length;
+      break;
+    }
+    cursor = closingTagIdx + '</think>'.length;
+  }
+
+  return removedThink ? out.trimStart() : out;
+}
+
+function sanitizeMiniMaxText(model, text) {
+  return isMiniMaxModel(model) ? stripMiniMaxThinkContent(text) : text;
+}
+
+function nextMiniMaxVisibleChunk(state, content) {
+  const rawChunk = extractTextContent(content);
+  if (!rawChunk) {
+    return { textDelta: '', nextState: state };
+  }
+
+  const nextRawContent = rawChunk.startsWith(state.rawContent) ? rawChunk : `${state.rawContent}${rawChunk}`;
+  const nextVisibleText = stripMiniMaxThinkContent(nextRawContent);
+  const textDelta = nextVisibleText.startsWith(state.visibleText)
+    ? nextVisibleText.slice(state.visibleText.length)
+    : nextVisibleText;
+
+  return {
+    textDelta,
+    nextState: {
+      rawContent: nextRawContent,
+      visibleText: nextVisibleText
+    }
+  };
+}
+
+export async function createChatCompletion({
+  baseUrl,
+  apiKey,
+  model,
+  messages,
+  temperature = 0.2,
+  tools,
+  timeoutMs = 90000,
+  maxRetries = 2
+}) {
+  const client = createClient({ baseUrl, apiKey, timeoutMs, maxRetries });
+  const payload = buildPayload({ model, temperature, messages, tools });
+
+  const data = await client.chat.completions.create(payload);
+  const message = data?.choices?.[0]?.message || {};
+  const text = sanitizeMiniMaxText(model, extractTextContent(message.content));
+  const toolCalls = (message.tool_calls || []).map((tc) => ({
+    id: tc.id,
+    name: tc.function?.name,
+    arguments: tc.function?.arguments || '{}'
+  }));
+
+  if (!text && toolCalls.length === 0) {
+    throw new Error('Gateway returned empty assistant response');
+  }
+
+  return {
+    text,
+    toolCalls,
+    usage: data?.usage || null
+  };
+}
+
+export async function createChatCompletionStream({
+  baseUrl,
+  apiKey,
+  model,
+  messages,
+  temperature = 0.2,
+  tools,
+  onTextDelta,
+  timeoutMs = 90000,
+  maxRetries = 2
+}) {
+  const client = createClient({ baseUrl, apiKey, timeoutMs, maxRetries });
+  const payload = buildPayload({ model, temperature, messages, tools, stream: true });
+
+  const stream = await client.chat.completions.create(payload);
+  let text = '';
+  const toolCallsByIndex = new Map();
+  let usage = null;
+  let miniMaxStreamState = { rawContent: '', visibleText: '' };
+
+  for await (const chunk of stream) {
+    usage = chunk?.usage || usage;
+    const choice0 = chunk?.choices?.[0] || {};
+    const delta = choice0?.delta || {};
+    const content = delta.content;
+    if (isMiniMaxModel(model)) {
+      const next = nextMiniMaxVisibleChunk(miniMaxStreamState, content);
+      miniMaxStreamState = next.nextState;
+      if (next.textDelta) {
+        text += next.textDelta;
+        if (onTextDelta) onTextDelta(next.textDelta);
+      }
+    } else if (typeof content === 'string' && content.length > 0) {
+      text += content;
+      if (onTextDelta) onTextDelta(content);
+    } else if (Array.isArray(content) && content.length > 0) {
+      const chunkText = extractTextContent(content);
+      if (chunkText) {
+        text += chunkText;
+        if (onTextDelta) onTextDelta(chunkText);
+      }
+    }
+
+    const toolDeltas = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
+    for (const td of toolDeltas) {
+      const idx = typeof td.index === 'number' ? td.index : 0;
+      const current = toolCallsByIndex.get(idx) || emptyToolCall(idx);
+      if (td.id) current.id = td.id;
+      if (td.function?.name) current.name = `${current.name}${td.function.name}`;
+      if (td.function?.arguments) current.arguments = `${current.arguments}${td.function.arguments}`;
+      toolCallsByIndex.set(idx, current);
+    }
+  }
+
+  return buildFinalStreamResult(text, toolCallsByIndex, usage);
+}

package/src/core/session-store.js

@@ -0,0 +1,178 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getSessionsDir } from './paths.js';
+
+const ALLOWED_ROLES = new Set(['system', 'user', 'assistant', 'tool']);
+
+function createSessionId() {
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  const rand = Math.random().toString(36).slice(2, 8);
+  return `${ts}-${rand}`;
+}
+
+function sanitizeToolCall(tc, index) {
+  const id = String(tc?.id || `tc-${index + 1}`);
+  const fnName = String(tc?.function?.name || tc?.name || '').trim();
+  const fnArgsRaw = tc?.function?.arguments ?? tc?.arguments ?? '{}';
+  const fnArgs = typeof fnArgsRaw === 'string' ? fnArgsRaw : JSON.stringify(fnArgsRaw);
+  if (!fnName) return null;
+  return {
+    id,
+    type: 'function',
+    function: {
+      name: fnName,
+      arguments: fnArgs
+    }
+  };
+}
+
+function sanitizeMessage(msg) {
+  const role = String(msg?.role || '').trim();
+  if (!ALLOWED_ROLES.has(role)) return null;
+  const content =
+    typeof msg?.content === 'string' || Array.isArray(msg?.content) ? msg.content : String(msg?.content || '');
+
+  const out = {
+    role,
+    content
+  };
+
+  if (msg?.tool_call_id) out.tool_call_id = String(msg.tool_call_id);
+  if (typeof msg?.name === 'string' && msg.name.trim()) out.name = msg.name.trim();
+  if (typeof msg?.at === 'string' && msg.at.trim()) out.at = msg.at;
+
+  if (Array.isArray(msg?.tool_calls)) {
+    const toolCalls = msg.tool_calls.map(sanitizeToolCall).filter(Boolean);
+    if (toolCalls.length > 0) out.tool_calls = toolCalls;
+  }
+
+  return out;
+}
+
+function sanitizeSession(session, fallbackId = '') {
+  const id = String(session?.id || fallbackId || '').trim();
+  if (!id) throw new Error('Session id is required');
+  const now = new Date().toISOString();
+  const createdAt = String(session?.createdAt || now);
+  const updatedAt = String(session?.updatedAt || now);
+  const messages = Array.isArray(session?.messages) ? session.messages.map(sanitizeMessage).filter(Boolean) : [];
+
+  const out = {
+    id,
+    createdAt,
+    updatedAt,
+    messages
+  };
+
+  if (session?.model) out.model = String(session.model);
+  if (session?.mode) out.mode = String(session.mode);
+
+  return out;
+}
+
+export async function createSession() {
+  const sessionId = createSessionId();
+  const dir = getSessionsDir();
+  await fs.mkdir(dir, { recursive: true });
+  const filePath = path.join(dir, `${sessionId}.json`);
+  const payload = {
+    id: sessionId,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    messages: []
+  };
+  await fs.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+  return payload;
+}
+
+export async function loadSession(sessionId) {
+  const filePath = path.join(getSessionsDir(), `${sessionId}.json`);
+  const raw = await fs.readFile(filePath, 'utf8');
+  return sanitizeSession(JSON.parse(raw), sessionId);
+}
+
+export async function saveSession(session) {
+  const dir = getSessionsDir();
+  await fs.mkdir(dir, { recursive: true });
+  const normalized = sanitizeSession(session);
+  normalized.updatedAt = new Date().toISOString();
+  const filePath = path.join(dir, `${normalized.id}.json`);
+  await fs.writeFile(filePath, `${JSON.stringify(normalized, null, 2)}\n`, 'utf8');
+}
+
+export async function resolveSession(sessionId) {
+  if (sessionId) {
+    return loadSession(sessionId);
+  }
+  return createSession();
+}
+
+export async function listSessions(limit = 30) {
+  const dir = getSessionsDir();
+  await fs.mkdir(dir, { recursive: true });
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  const files = entries
+    .filter((e) => e.isFile() && e.name.endsWith('.json'))
+    .map((e) => path.join(dir, e.name));
+
+  const sessions = [];
+  for (const file of files) {
+    try {
+      const raw = await fs.readFile(file, 'utf8');
+      const parsed = JSON.parse(raw);
+      const id = parsed.id || path.basename(file, '.json');
+      const updatedAt = parsed.updatedAt || parsed.createdAt || '';
+      const latestMessage = Array.isArray(parsed.messages) ? parsed.messages.at(-1) : null;
+      const preview = latestMessage?.content
+        ? String(latestMessage.content).replace(/\s+/g, ' ').slice(0, 80)
+        : '';
+      sessions.push({
+        id,
+        updatedAt,
+        messageCount: Array.isArray(parsed.messages) ? parsed.messages.length : 0,
+        preview
+      });
+    } catch {
+      continue;
+    }
+  }
+
+  sessions.sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)));
+  return sessions.filter((s) => Number(s.messageCount || 0) > 0).slice(0, limit);
+}
+
+export async function pruneSessions(policy = {}) {
+  const maxSessions = Number(policy.max_sessions || 100);
+  const retentionDays = Number(policy.retention_days || 30);
+  const all = await listSessions(10000);
+  const now = Date.now();
+  const expireMs = retentionDays > 0 ? retentionDays * 24 * 60 * 60 * 1000 : 0;
+  const keepIds = new Set();
+
+  const sorted = [...all].sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)));
+  for (let i = 0; i < sorted.length; i += 1) {
+    const s = sorted[i];
+    if (i >= maxSessions) continue;
+    if (expireMs > 0 && s.updatedAt) {
+      const t = Date.parse(s.updatedAt);
+      if (!Number.isNaN(t) && now - t > expireMs) continue;
+    }
+    keepIds.add(s.id);
+  }
+
+  const dir = getSessionsDir();
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  let removed = 0;
+  for (const e of entries) {
+    if (!e.isFile() || !e.name.endsWith('.json')) continue;
+    const id = path.basename(e.name, '.json');
+    if (keepIds.has(id)) continue;
+    try {
+      await fs.unlink(path.join(dir, e.name));
+      removed += 1;
+    } catch {
+      continue;
+    }
+  }
+  return { removed, kept: keepIds.size };
+}

package/src/core/shell-profile.js

@@ -0,0 +1,122 @@
+const DEFAULT_SHELL = process.platform === 'win32' ? 'powershell' : 'bash';
+
+function uniqueStrings(items = []) {
+  const out = [];
+  const seen = new Set();
+  for (const item of items) {
+    const value = String(item || '').trim();
+    if (!value || seen.has(value)) continue;
+    seen.add(value);
+    out.push(value);
+  }
+  return out;
+}
+
+const SHELL_PROFILES = {
+  powershell: {
+    shell: 'powershell',
+    label: 'PowerShell',
+    command_allowlist: [
+      'rg',
+      'git',
+      'node',
+      'npm',
+      'npx',
+      'python',
+      'py',
+      'pip',
+      'get-childitem',
+      'get-content',
+      'select-string',
+      'set-content',
+      'new-item',
+      'copy-item',
+      'move-item',
+      'pwd'
+    ],
+    blocked_commands: [
+      'del',
+      'erase',
+      'rmdir',
+      'rd',
+      'format',
+      'diskpart',
+      'cipher',
+      'bcdedit',
+      'reg',
+      'takeown',
+      'icacls',
+      'remove-item'
+    ],
+    blocked_path_patterns: [
+      'c:\\windows',
+      'c:\\program files',
+      'c:\\program files (x86)',
+      'c:\\users\\default',
+      '%systemroot%',
+      '$env:systemroot'
+    ]
+  },
+  bash: {
+    shell: 'bash',
+    label: 'bash',
+    command_allowlist: [
+      'rg',
+      'find',
+      'grep',
+      'git',
+      'node',
+      'npm',
+      'npx',
+      'python',
+      'pip',
+      'ls',
+      'cat',
+      'sed',
+      'cp',
+      'mv',
+      'mkdir',
+      'pwd'
+    ],
+    blocked_commands: ['rm', 'sudo', 'su', 'dd', 'mkfs', 'mount', 'umount', 'chmod', 'chown'],
+    blocked_path_patterns: ['/etc/', '/bin/', '/usr/', '/var/', '/sys/', '/proc/', '/system/', '/library/']
+  }
+};
+
+export function normalizeShellName(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  if (raw === 'pwsh') return 'powershell';
+  if (raw === 'sh' || raw === 'zsh') return 'bash';
+  if (raw === 'cmd') return 'powershell';
+  if (raw === 'powershell' || raw === 'bash') return raw;
+  return DEFAULT_SHELL;
+}
+
+export function getShellProfile(value) {
+  return SHELL_PROFILES[normalizeShellName(value)];
+}
+
+export function getEffectivePolicy(config) {
+  const profile = getShellProfile(config?.shell?.default);
+  const policy = config?.policy || {};
+  return {
+    ...policy,
+    command_allowlist: uniqueStrings([
+      ...(Array.isArray(profile.command_allowlist) ? profile.command_allowlist : []),
+      ...(Array.isArray(policy.command_allowlist) ? policy.command_allowlist : [])
+    ]),
+    blocked_commands: uniqueStrings([
+      ...(Array.isArray(profile.blocked_commands) ? profile.blocked_commands : []),
+      ...(Array.isArray(policy.blocked_commands) ? policy.blocked_commands : [])
+    ]),
+    blocked_path_patterns: uniqueStrings([
+      ...(Array.isArray(profile.blocked_path_patterns) ? profile.blocked_path_patterns : []),
+      ...(Array.isArray(policy.blocked_path_patterns) ? policy.blocked_path_patterns : [])
+    ])
+  };
+}
+
+export function getShellSystemPrompt(value) {
+  const profile = getShellProfile(value);
+  return `You are CodeMini CLI working in a ${profile.label} shell environment. For codebase exploration, use the allowed shell search and context commands that best fit the task, then use read_file only when command output is not enough. Use write_file for edits and always provide a concrete file path, not a directory. Avoid unnecessary tool calls.`;
+}