codemini-cli 0.1.1

package/src/core/checkpoint-store.js

@@ -0,0 +1,66 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+function checkpointsDir(cwd = process.cwd()) {
+  return path.join(cwd, '.coder', 'checkpoints');
+}
+
+function makeId(name = '') {
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const slug = String(name || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9\u4e00-\u9fa5]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 48);
+  return `${stamp}-${slug || 'checkpoint'}`;
+}
+
+export async function createCheckpoint({ name, session, config, tasks }, cwd = process.cwd()) {
+  const dir = checkpointsDir(cwd);
+  await fs.mkdir(dir, { recursive: true });
+  const id = makeId(name);
+  const filePath = path.join(dir, `${id}.json`);
+  const payload = {
+    id,
+    name: String(name || ''),
+    createdAt: new Date().toISOString(),
+    session,
+    config,
+    tasks: Array.isArray(tasks) ? tasks : []
+  };
+  await fs.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+  return payload;
+}
+
+export async function listCheckpoints(cwd = process.cwd()) {
+  const dir = checkpointsDir(cwd);
+  await fs.mkdir(dir, { recursive: true });
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  const out = [];
+  for (const e of entries) {
+    if (!e.isFile() || !e.name.endsWith('.json')) continue;
+    const filePath = path.join(dir, e.name);
+    try {
+      const raw = await fs.readFile(filePath, 'utf8');
+      const parsed = JSON.parse(raw);
+      out.push({
+        id: parsed.id || path.basename(e.name, '.json'),
+        name: parsed.name || '',
+        createdAt: parsed.createdAt || '',
+        sessionId: parsed?.session?.id || '',
+        filePath
+      });
+    } catch {
+      continue;
+    }
+  }
+  out.sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt)));
+  return out;
+}
+
+export async function loadCheckpoint(id, cwd = process.cwd()) {
+  const dir = checkpointsDir(cwd);
+  const filePath = path.join(dir, `${id}.json`);
+  const raw = await fs.readFile(filePath, 'utf8');
+  return JSON.parse(raw);
+}

package/src/core/command-loader.js

@@ -0,0 +1,201 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  getCommandsDir,
+  getLegacyGlobalSkillsDir,
+  getLegacyProjectSkillsDir,
+  getProjectCommandsDir,
+  getSkillsDir
+} from './paths.js';
+import { readSkillRegistry } from './skill-registry.js';
+
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const BUNDLED_SKILLS_DIR = path.resolve(MODULE_DIR, '..', '..', 'skills');
+
+function parseArrayText(value) {
+  const inner = value.slice(1, -1).trim();
+  if (!inner) return [];
+  return inner.split(',').map((item) => item.trim().replace(/^["']|["']$/g, ''));
+}
+
+function parseFrontmatter(raw) {
+  if (!raw.startsWith('---\n')) {
+    return { metadata: {}, content: raw };
+  }
+  const end = raw.indexOf('\n---\n', 4);
+  if (end === -1) {
+    return { metadata: {}, content: raw };
+  }
+
+  const metaRaw = raw.slice(4, end).trim();
+  const content = raw.slice(end + 5).trim();
+  const metadata = {};
+
+  for (const line of metaRaw.split('\n')) {
+    const idx = line.indexOf(':');
+    if (idx <= 0) continue;
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim();
+    if (value.startsWith('[') && value.endsWith(']')) {
+      metadata[key] = parseArrayText(value);
+    } else {
+      metadata[key] = value.replace(/^["']|["']$/g, '');
+    }
+  }
+
+  return { metadata, content };
+}
+
+function safeEntries(dir) {
+  try {
+    return fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+
+function isSafeEntry(entry) {
+  return entry !== '.' && entry !== '..' && !entry.includes('/') && !entry.includes('\\');
+}
+
+function loadMarkdownCommandsFromDir(baseDir, source, out) {
+  if (!fs.existsSync(baseDir)) return;
+  for (const entry of safeEntries(baseDir)) {
+    if (!isSafeEntry(entry)) continue;
+    const full = path.join(baseDir, entry);
+    const stat = fs.statSync(full);
+
+    if (stat.isDirectory()) {
+      const commandFile = path.join(full, `${entry}.md`);
+      if (fs.existsSync(commandFile)) {
+        const raw = fs.readFileSync(commandFile, 'utf8');
+        const parsed = parseFrontmatter(raw);
+        out.set(entry, {
+          name: entry,
+          source,
+          path: commandFile,
+          metadata: parsed.metadata,
+          content: parsed.content
+        });
+      }
+      continue;
+    }
+
+    if (entry.endsWith('.md')) {
+      const name = entry.replace(/\.md$/, '');
+      const raw = fs.readFileSync(full, 'utf8');
+      const parsed = parseFrontmatter(raw);
+      out.set(name, {
+        name,
+        source,
+        path: full,
+        metadata: parsed.metadata,
+        content: parsed.content
+      });
+    }
+  }
+}
+
+function loadLegacySkillsFromDir(baseDir, source, out) {
+  if (!fs.existsSync(baseDir)) return;
+  for (const entry of safeEntries(baseDir)) {
+    if (!isSafeEntry(entry)) continue;
+    const full = path.join(baseDir, entry);
+    const stat = fs.statSync(full);
+    if (!stat.isDirectory()) continue;
+    const skillFile = path.join(full, 'SKILL.md');
+    if (!fs.existsSync(skillFile)) continue;
+    const raw = fs.readFileSync(skillFile, 'utf8');
+    const parsed = parseFrontmatter(raw);
+    out.set(entry, {
+      name: entry,
+      source: `${source}-skill`,
+      path: skillFile,
+      metadata: {
+        description: parsed.metadata.description || 'Legacy skill',
+        type: 'skill'
+      },
+      content: parsed.content
+    });
+  }
+}
+
+function loadBundledSkillsFromDir(baseDir, out) {
+  if (!fs.existsSync(baseDir)) return;
+  for (const entry of safeEntries(baseDir)) {
+    if (!isSafeEntry(entry)) continue;
+    const full = path.join(baseDir, entry);
+    const stat = fs.statSync(full);
+    if (!stat.isDirectory()) continue;
+    const skillFile = path.join(full, 'SKILL.md');
+    if (!fs.existsSync(skillFile)) continue;
+    const raw = fs.readFileSync(skillFile, 'utf8');
+    const parsed = parseFrontmatter(raw);
+    out.set(entry, {
+      name: entry,
+      source: 'bundled-skill',
+      path: skillFile,
+      metadata: {
+        ...parsed.metadata,
+        type: 'skill',
+        version: parsed.metadata.version || '0.1.0',
+        description: parsed.metadata.description || 'Bundled skill'
+      },
+      content: parsed.content
+    });
+  }
+}
+
+function loadInstalledSkillsFromRegistry(baseDir, registry, out) {
+  if (!registry || !Array.isArray(registry.skills)) return;
+  for (const skill of registry.skills) {
+    if (skill.enabled === false) continue;
+    const name = skill.name;
+    const entry = skill.entryFile || 'SKILL.md';
+    const full = path.join(baseDir, name, entry);
+    if (!fs.existsSync(full)) continue;
+    const raw = fs.readFileSync(full, 'utf8');
+    const parsed = parseFrontmatter(raw);
+    out.set(name, {
+      name,
+      source: 'registry-skill',
+      path: full,
+      metadata: {
+        ...parsed.metadata,
+        type: 'skill',
+        version: skill.version || parsed.metadata.version || '0.0.0',
+        description: skill.description || parsed.metadata.description || 'Installed skill'
+      },
+      content: parsed.content
+    });
+  }
+}
+
+function substituteVariables(text, args = []) {
+  let out = text;
+  args.forEach((arg, index) => {
+    out = out.replaceAll(`{{${index + 1}}}`, arg);
+  });
+  out = out.replaceAll('{{args}}', args.join(' '));
+  out = out.replaceAll('{{cwd}}', process.cwd());
+  return out;
+}
+
+export async function loadCommandsAndSkills(cwd = process.cwd()) {
+  const commands = new Map();
+
+  loadBundledSkillsFromDir(BUNDLED_SKILLS_DIR, commands);
+  loadMarkdownCommandsFromDir(getCommandsDir(), 'global', commands);
+  loadMarkdownCommandsFromDir(getProjectCommandsDir(cwd), 'project', commands);
+  loadLegacySkillsFromDir(getLegacyGlobalSkillsDir(), 'global', commands);
+  loadLegacySkillsFromDir(getLegacyProjectSkillsDir(cwd), 'project', commands);
+  const registry = await readSkillRegistry();
+  loadInstalledSkillsFromRegistry(getSkillsDir(), registry, commands);
+
+  return commands;
+}
+
+export function renderCommandPrompt(command, args) {
+  return `[Executing ${command.metadata.type === 'skill' ? 'skill' : 'command'}: /${command.name}]\n\n${substituteVariables(command.content, args)}`;
+}

package/src/core/command-policy.js

@@ -0,0 +1,71 @@
+import path from 'node:path';
+import { getEffectivePolicy } from './shell-profile.js';
+
+function firstToken(command) {
+  const m = String(command || '').trim().match(/^"([^"]+)"|^'([^']+)'|^(\S+)/);
+  const raw = (m && (m[1] || m[2] || m[3])) || '';
+  const base = path.basename(raw).toLowerCase();
+  return base.replace(/\.exe$/i, '');
+}
+
+function includesAny(haystackLower, patterns = []) {
+  return patterns.some((p) => haystackLower.includes(String(p).toLowerCase()));
+}
+
+function suggestionForToken(token, config) {
+  const shell = String(config?.shell?.default || '').toLowerCase();
+  if (token === 'find' || token === 'grep') {
+    return shell === 'powershell'
+      ? 'Use allowed search and context commands such as Get-ChildItem, Select-String, Get-Content, or rg when available.'
+      : 'Use allowed search and context commands such as rg, find, grep, sed, cat, or ls.';
+  }
+  if (shell === 'powershell') {
+    return 'Use allowed shell commands for search and local context such as Get-ChildItem, Get-Content, Select-String, or rg when available.';
+  }
+  return 'Use allowed shell commands for search and local context such as rg, find, grep, sed, cat, or ls.';
+}
+
+export function evaluateCommandPolicy(command, config, workspaceRoot = process.cwd()) {
+  const policy = getEffectivePolicy(config);
+  const cmd = String(command || '').trim();
+  const lower = cmd.toLowerCase();
+  if (!cmd) {
+    return { allowed: false, reason: 'empty command' };
+  }
+
+  if (!policy.allow_dangerous_commands && includesAny(lower, policy.blocked_command_patterns)) {
+    return { allowed: false, reason: 'blocked by dangerous command pattern' };
+  }
+
+  if (!policy.safe_mode) {
+    return { allowed: true };
+  }
+
+  if (includesAny(lower, policy.blocked_path_patterns)) {
+    return { allowed: false, reason: 'blocked protected system path' };
+  }
+
+  const token = firstToken(cmd);
+  if (includesAny(token, policy.blocked_commands)) {
+    return { allowed: false, reason: `blocked command: ${token}`, suggestion: suggestionForToken(token, config) };
+  }
+
+  const allowlist = Array.isArray(policy.command_allowlist) ? policy.command_allowlist : [];
+  if (allowlist.length > 0 && !allowlist.includes(token)) {
+    return {
+      allowed: false,
+      reason: `command not in allowlist: ${token}`,
+      suggestion: suggestionForToken(token, config)
+    };
+  }
+
+  const workspaceLower = String(workspaceRoot).toLowerCase().replace(/\//g, '\\');
+  const windowsAbsPath = lower.match(/[a-z]:\\[^\s'"]+/g) || [];
+  for (const p of windowsAbsPath) {
+    if (!p.startsWith(workspaceLower)) {
+      return { allowed: false, reason: `absolute path outside workspace: ${p}`, suggestion: suggestionForToken(token, config) };
+    }
+  }
+
+  return { allowed: true };
+}

package/src/core/config-store.js

@@ -0,0 +1,196 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getConfigFilePath, getLegacyConfigDir } from './paths.js';
+import { normalizeShellName } from './shell-profile.js';
+
+function normalizeUiLanguage(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  if (!raw) return 'zh';
+  if (['en', 'en-us', 'en_us', 'english'].includes(raw)) return 'en';
+  if (['zh', 'zh-cn', 'zh_cn', 'cn', 'chinese'].includes(raw)) return 'zh';
+  return 'zh';
+}
+
+const DEFAULT_CONFIG = {
+  gateway: {
+    base_url: 'http://127.0.0.1:8000/v1',
+    api_key: '',
+    timeout_ms: 90000,
+    max_retries: 2
+  },
+  model: {
+    name: 'gpt-4.1-mini',
+    max_context_tokens: 202752
+  },
+  context: {
+    max_tokens: 32000,
+    preflight_trigger_pct: 92,
+    hard_limit_pct: 98,
+    tool_result_max_chars: 12000,
+    read_file_default_lines: 220,
+    read_file_max_chars: 24000
+  },
+  execution: {
+    mode: 'auto',
+    always_allow_tools: ['run_command', 'read_file', 'write_file'],
+    max_steps: 16
+  },
+  sessions: {
+    max_sessions: 100,
+    retention_days: 30
+  },
+  shell: {
+    default: normalizeShellName(process.platform === 'win32' ? 'powershell' : 'bash'),
+    timeout_ms: 120000
+  },
+  ui: {
+    language: 'zh'
+  },
+  soul: {
+    preset: 'default',
+    custom_path: ''
+  },
+  policy: {
+    safe_mode: true,
+    allow_dangerous_commands: false,
+    command_allowlist: [],
+    blocked_commands: [],
+    blocked_path_patterns: [],
+    blocked_command_patterns: ['rm -rf /', 'format c:', 'del /f /s /q C:\\\\']
+  },
+  skills: {
+    enabled: {}
+  }
+};
+
+async function ensureDir(filePath) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+}
+
+function isObject(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+function deepMerge(base, extra) {
+  if (!isObject(base) || !isObject(extra)) {
+    return extra;
+  }
+  const out = { ...base };
+  for (const [k, v] of Object.entries(extra)) {
+    if (k in out) {
+      out[k] = deepMerge(out[k], v);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+function uniqueStrings(items = []) {
+  const out = [];
+  const seen = new Set();
+  for (const it of items) {
+    const v = String(it || '').trim();
+    if (!v || seen.has(v)) continue;
+    seen.add(v);
+    out.push(v);
+  }
+  return out;
+}
+
+function normalizePolicyLists(config) {
+  const next = structuredClone(config);
+  next.shell = next.shell || {};
+  next.shell.default = normalizeShellName(next.shell.default);
+  next.execution = next.execution || {};
+  next.execution.mode = ['auto', 'normal', 'plan'].includes(String(next.execution.mode || '').toLowerCase())
+    ? String(next.execution.mode).toLowerCase()
+    : 'auto';
+  const rawTools = Array.isArray(next.execution.always_allow_tools)
+    ? next.execution.always_allow_tools
+    : [];
+  next.execution.always_allow_tools = uniqueStrings(
+    ['run_command', 'read_file', 'write_file', ...rawTools].filter((name) => String(name) !== 'list_files')
+  );
+  next.ui = next.ui || {};
+  next.ui.language = normalizeUiLanguage(next.ui.language);
+  next.policy = next.policy || {};
+  next.policy.command_allowlist = uniqueStrings(
+    Array.isArray(next.policy.command_allowlist) ? next.policy.command_allowlist : []
+  );
+  next.policy.blocked_commands = uniqueStrings(
+    Array.isArray(next.policy.blocked_commands) ? next.policy.blocked_commands : []
+  );
+  next.policy.blocked_path_patterns = uniqueStrings(
+    Array.isArray(next.policy.blocked_path_patterns) ? next.policy.blocked_path_patterns : []
+  );
+  return next;
+}
+
+function getNested(obj, keyPath) {
+  return keyPath.split('.').reduce((acc, k) => (acc && k in acc ? acc[k] : undefined), obj);
+}
+
+function parseValue(input) {
+  if (input === 'true') return true;
+  if (input === 'false') return false;
+  if (input === 'null') return null;
+  if (!Number.isNaN(Number(input)) && input.trim() !== '') return Number(input);
+  return input;
+}
+
+function setNested(obj, keyPath, rawValue) {
+  const value = parseValue(rawValue);
+  const parts = keyPath.split('.');
+  let cursor = obj;
+  for (let i = 0; i < parts.length - 1; i += 1) {
+    const p = parts[i];
+    if (!isObject(cursor[p])) {
+      cursor[p] = {};
+    }
+    cursor = cursor[p];
+  }
+  cursor[parts[parts.length - 1]] = value;
+}
+
+export async function loadConfig() {
+  const configPath = getConfigFilePath();
+  try {
+    const raw = await fs.readFile(configPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return normalizePolicyLists(deepMerge(DEFAULT_CONFIG, parsed));
+  } catch {
+    if (process.env.CODEMINI_CONFIG_DIR || process.env.COMPANY_CODER_CONFIG_DIR) {
+      return normalizePolicyLists(structuredClone(DEFAULT_CONFIG));
+    }
+    try {
+      const legacyPath = path.join(getLegacyConfigDir(), 'config.json');
+      const raw = await fs.readFile(legacyPath, 'utf8');
+      const parsed = JSON.parse(raw);
+      return normalizePolicyLists(deepMerge(DEFAULT_CONFIG, parsed));
+    } catch {
+      return normalizePolicyLists(structuredClone(DEFAULT_CONFIG));
+    }
+  }
+}
+
+export async function saveConfig(config) {
+  const configPath = getConfigFilePath();
+  await ensureDir(configPath);
+  await fs.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+}
+
+export async function setConfigValue(keyPath, value) {
+  const config = await loadConfig();
+  setNested(config, keyPath, value);
+  await saveConfig(config);
+}
+
+export async function getConfigValue(keyPath) {
+  const config = await loadConfig();
+  return getNested(config, keyPath);
+}
+
+export async function resetConfig() {
+  await saveConfig(structuredClone(DEFAULT_CONFIG));
+}

package/src/core/context-compact.js

@@ -0,0 +1,90 @@
+function textFromContent(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 '';
+}
+
+export function estimateMessagesTokens(messages) {
+  let total = 0;
+  for (const message of messages || []) {
+    const roleOverhead = 6;
+    const text = textFromContent(message.content);
+    total += roleOverhead + Math.ceil(text.length / 4);
+  }
+  return total;
+}
+
+function modeToKeepRecent(mode) {
+  if (mode === 'aggressive') return 4;
+  if (mode === 'conservative') return 10;
+  return 6;
+}
+
+function buildLocalSummary(messages) {
+  const lines = [];
+  const limit = 12;
+  for (const msg of messages.slice(-limit)) {
+    const text = textFromContent(msg.content).replace(/\s+/g, ' ').trim();
+    if (!text) continue;
+    const clipped = text.length > 160 ? `${text.slice(0, 160)}...` : text;
+    lines.push(`- ${msg.role}: ${clipped}`);
+  }
+  return `Context Summary\n${lines.join('\n')}`.trim();
+}
+
+export function compactMessagesLocally(messages, { mode = 'default' } = {}) {
+  const keepRecent = modeToKeepRecent(mode);
+  if (!Array.isArray(messages) || messages.length <= keepRecent + 1) {
+    return {
+      compacted: [...(messages || [])],
+      changed: false
+    };
+  }
+
+  const older = messages.slice(0, Math.max(0, messages.length - keepRecent));
+  const recent = messages.slice(Math.max(0, messages.length - keepRecent));
+  const summary = buildLocalSummary(older);
+  const compacted = [{ role: 'assistant', content: summary }, ...recent];
+
+  return {
+    compacted,
+    changed: true,
+    summary
+  };
+}
+
+export function parseCompactArgs(args = []) {
+  const parsed = {
+    mode: 'default',
+    preview: false,
+    restore: false,
+    auto: undefined,
+    threshold: undefined
+  };
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--preview') parsed.preview = true;
+    if (arg === '--restore') parsed.restore = true;
+    if (arg === '--aggressive') parsed.mode = 'aggressive';
+    if (arg === '--conservative') parsed.mode = 'conservative';
+    if (arg === '--default') parsed.mode = 'default';
+    if (arg === '--auto-on') parsed.auto = 'on';
+    if (arg === '--auto-off') parsed.auto = 'off';
+    if (arg === '--threshold') {
+      const n = Number(args[i + 1]);
+      if (!Number.isNaN(n)) parsed.threshold = n;
+      i += 1;
+    }
+  }
+
+  return parsed;
+}

package/src/core/default-system-prompt.js

@@ -0,0 +1,5 @@
+import { getShellSystemPrompt } from './shell-profile.js';
+
+export function buildDefaultSystemPrompt(config = {}) {
+  return `${getShellSystemPrompt(config?.shell?.default)} If a command or tool is blocked or fails, inspect the error and retry with allowed commands or tools. Do not claim filesystem access is impossible unless the allowed search/read tools also fail.`;
+}

package/src/core/fs-utils.js

@@ -0,0 +1,16 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export async function copyRecursive(src, dest) {
+  const stat = await fs.stat(src);
+  if (stat.isDirectory()) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src);
+    for (const entry of entries) {
+      await copyRecursive(path.join(src, entry), path.join(dest, entry));
+    }
+    return;
+  }
+  await fs.mkdir(path.dirname(dest), { recursive: true });
+  await fs.copyFile(src, dest);
+}

package/src/core/input-history-store.js

@@ -0,0 +1,48 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getInputHistoryFilePath } from './paths.js';
+
+const MAX_HISTORY = 300;
+
+async function ensureDir(filePath) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+}
+
+function normalizeList(value) {
+  if (!Array.isArray(value)) return [];
+  const lines = value
+    .map((v) => String(v || '').trim())
+    .filter(Boolean);
+  if (lines.length <= MAX_HISTORY) return lines;
+  return lines.slice(lines.length - MAX_HISTORY);
+}
+
+export async function loadInputHistory() {
+  const filePath = getInputHistoryFilePath();
+  try {
+    const raw = await fs.readFile(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return normalizeList(parsed?.items);
+  } catch {
+    return [];
+  }
+}
+
+export async function appendInputHistory(line) {
+  const normalized = String(line || '').trim();
+  if (!normalized) return [];
+
+  const filePath = getInputHistoryFilePath();
+  const existing = await loadInputHistory();
+  const next = existing.filter((v) => v !== normalized);
+  next.push(normalized);
+  const finalList = normalizeList(next);
+
+  await ensureDir(filePath);
+  await fs.writeFile(
+    filePath,
+    `${JSON.stringify({ updatedAt: new Date().toISOString(), items: finalList }, null, 2)}\n`,
+    'utf8'
+  );
+  return finalList;
+}