codemini-cli 0.1.1

package/src/core/shell.js

@@ -0,0 +1,71 @@
+import { spawn } from 'node:child_process';
+
+function resolveShell(defaultShell) {
+  if (process.platform === 'win32') {
+    if (defaultShell === 'cmd') {
+      return { command: 'cmd.exe', args: ['/d', '/s', '/c'] };
+    }
+    if (defaultShell === 'bash') {
+      return { command: 'bash.exe', args: ['-lc'] };
+    }
+    return { command: 'powershell.exe', args: ['-NoLogo', '-NoProfile', '-Command'] };
+  }
+
+  if (defaultShell === 'powershell') {
+    return { command: 'pwsh', args: ['-NoLogo', '-NoProfile', '-Command'] };
+  }
+
+  return { command: '/bin/bash', args: ['-lc'] };
+}
+
+export function isDangerousCommand(command, blockedPatterns = []) {
+  const lowered = command.toLowerCase();
+  return blockedPatterns.some((pattern) => lowered.includes(String(pattern).toLowerCase()));
+}
+
+export function runShellCommand({
+  command,
+  cwd = process.cwd(),
+  shell = 'powershell',
+  timeoutMs = 120000
+}) {
+  const shellSpec = resolveShell(shell);
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(shellSpec.command, [...shellSpec.args, command], {
+      cwd,
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill('SIGTERM');
+    }, timeoutMs);
+
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (timedOut) {
+        reject(new Error(`Command timed out after ${timeoutMs}ms`));
+        return;
+      }
+      resolve({ code, stdout, stderr });
+    });
+  });
+}

package/src/core/skill-registry.js

@@ -0,0 +1,55 @@
+import fs from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import { getSkillRegistryPath as getSkillRegistryPathFromPaths } from './paths.js';
+
+function defaultRegistry() {
+  return {
+    version: 1,
+    updatedAt: new Date().toISOString(),
+    skills: []
+  };
+}
+
+export function getSkillRegistryPath() {
+  return getSkillRegistryPathFromPaths();
+}
+
+export async function readSkillRegistry(registryPath = getSkillRegistryPath()) {
+  try {
+    const raw = await fs.readFile(registryPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.skills)) {
+      return defaultRegistry();
+    }
+    return parsed;
+  } catch {
+    return defaultRegistry();
+  }
+}
+
+export async function writeSkillRegistry(registryPath = getSkillRegistryPath(), registry) {
+  await fs.mkdir(path.dirname(registryPath), { recursive: true });
+  registry.updatedAt = new Date().toISOString();
+  await fs.writeFile(registryPath, `${JSON.stringify(registry, null, 2)}\n`, 'utf8');
+}
+
+export async function upsertSkillRegistryEntry(registryPath = getSkillRegistryPath(), entry) {
+  const registry = await readSkillRegistry(registryPath);
+  const index = registry.skills.findIndex((s) => s.name === entry.name);
+  if (index === -1) {
+    registry.skills.push(entry);
+  } else {
+    registry.skills[index] = { ...registry.skills[index], ...entry };
+  }
+  await writeSkillRegistry(registryPath, registry);
+}
+
+export function getEnabledSkills(registry) {
+  return (registry.skills || []).filter((s) => s.enabled !== false);
+}
+
+export async function computeFileSha256(filePath) {
+  const content = await fs.readFile(filePath);
+  return createHash('sha256').update(content).digest('hex');
+}

package/src/core/soul.js

@@ -0,0 +1,55 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getBaseConfigDir } from './paths.js';
+
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const BUNDLED_SOULS_DIR = path.resolve(MODULE_DIR, '..', '..', 'souls');
+
+function normalizeSoulName(value) {
+  const name = String(value || '').trim().toLowerCase();
+  return name || 'default';
+}
+
+function resolveCustomSoulPath(customPath = '') {
+  const raw = String(customPath || '').trim();
+  if (!raw) return '';
+  if (path.isAbsolute(raw)) return raw;
+  return path.join(getBaseConfigDir(), raw);
+}
+
+export async function loadSoulPrompt(config = {}) {
+  const customPath = resolveCustomSoulPath(config?.soul?.custom_path);
+  if (customPath) {
+    try {
+      const content = await fs.readFile(customPath, 'utf8');
+      const text = String(content || '').trim();
+      if (text) return `[Soul custom]\n${text}`;
+    } catch {
+      // fall through to bundled preset
+    }
+  }
+
+  const preset = normalizeSoulName(config?.soul?.preset);
+  const presetPath = path.join(BUNDLED_SOULS_DIR, `${preset}.md`);
+  try {
+    const content = await fs.readFile(presetPath, 'utf8');
+    const text = String(content || '').trim();
+    if (text) return `[Soul preset: ${preset}]\n${text}`;
+  } catch {
+    // fall through to default preset
+  }
+
+  const defaultContent = await fs.readFile(path.join(BUNDLED_SOULS_DIR, 'default.md'), 'utf8');
+  return `[Soul preset: default]\n${String(defaultContent || '').trim()}`;
+}
+
+export async function buildSystemPromptWithSoul(baseSystemPrompt, config = {}) {
+  const soulPrompt = await loadSoulPrompt(config);
+  const guard = [
+    '[Soul guard]',
+    'Apply this soul to response tone only.',
+    'Response tone only: do not change plans, code, tests, file formats, or technical decisions.'
+  ].join('\n');
+  return `${String(baseSystemPrompt || '').trim()}\n\n${guard}\n\n${soulPrompt}`.trim();
+}

package/src/core/task-store.js

@@ -0,0 +1,116 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+function legacyTasksFilePath(cwd = process.cwd()) {
+  return path.join(cwd, '.coder', 'tasks.json');
+}
+
+function tasksFilePath(cwd = process.cwd(), sessionId = '') {
+  const sid = String(sessionId || '').trim();
+  if (!sid) return legacyTasksFilePath(cwd);
+  return path.join(cwd, '.coder', 'tasks', `${sid}.json`);
+}
+
+async function ensureDir(filePath) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+}
+
+function normalizeTasks(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((t) => ({
+      id: String(t?.id || '').trim(),
+      title: String(t?.title || '').trim(),
+      status: String(t?.status || 'pending').trim() || 'pending',
+      description: String(t?.description || '').trim(),
+      createdAt: String(t?.createdAt || ''),
+      updatedAt: String(t?.updatedAt || '')
+    }))
+    .filter((t) => t.id && t.title);
+}
+
+function createTaskId() {
+  const ts = Date.now().toString(36);
+  const rnd = Math.random().toString(36).slice(2, 7);
+  return `task-${ts}-${rnd}`;
+}
+
+export async function loadTasks(cwd = process.cwd(), sessionId = '') {
+  const filePath = tasksFilePath(cwd, sessionId);
+  try {
+    const raw = await fs.readFile(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return normalizeTasks(parsed?.tasks);
+  } catch {
+    if (sessionId) {
+      try {
+        const raw = await fs.readFile(legacyTasksFilePath(cwd), 'utf8');
+        const parsed = JSON.parse(raw);
+        return normalizeTasks(parsed?.tasks);
+      } catch {
+        return [];
+      }
+    }
+    return [];
+  }
+}
+
+export async function saveTasks(tasks, cwd = process.cwd(), sessionId = '') {
+  const filePath = tasksFilePath(cwd, sessionId);
+  await ensureDir(filePath);
+  const normalized = normalizeTasks(tasks);
+  await fs.writeFile(
+    filePath,
+    `${JSON.stringify({ updatedAt: new Date().toISOString(), tasks: normalized }, null, 2)}\n`,
+    'utf8'
+  );
+  return normalized;
+}
+
+export async function createTasks(items, cwd = process.cwd(), sessionId = '') {
+  const existing = await loadTasks(cwd, sessionId);
+  const now = new Date().toISOString();
+  const input = Array.isArray(items) ? items : [];
+  const add = input
+    .map((t) => ({
+      id: createTaskId(),
+      title: String(t?.title || '').trim(),
+      description: String(t?.description || '').trim(),
+      status: 'pending',
+      createdAt: now,
+      updatedAt: now
+    }))
+    .filter((t) => t.title);
+  const next = [...existing, ...add];
+  await saveTasks(next, cwd, sessionId);
+  return add;
+}
+
+export async function updateTask(taskId, patch, cwd = process.cwd(), sessionId = '') {
+  const tasks = await loadTasks(cwd, sessionId);
+  const idx = tasks.findIndex((t) => t.id === taskId);
+  if (idx === -1) return null;
+  const next = [...tasks];
+  const status = String(patch?.status || next[idx].status).trim();
+  next[idx] = {
+    ...next[idx],
+    ...(patch?.title ? { title: String(patch.title) } : {}),
+    ...(patch?.description !== undefined ? { description: String(patch.description || '') } : {}),
+    status: ['pending', 'in_progress', 'completed'].includes(status) ? status : next[idx].status,
+    updatedAt: new Date().toISOString()
+  };
+  await saveTasks(next, cwd, sessionId);
+  return next[idx];
+}
+
+export async function deleteTasks(ids, cwd = process.cwd(), sessionId = '') {
+  const remove = new Set((Array.isArray(ids) ? ids : []).map((v) => String(v)));
+  const before = await loadTasks(cwd, sessionId);
+  const kept = before.filter((t) => !remove.has(t.id));
+  await saveTasks(kept, cwd, sessionId);
+  return { removed: before.length - kept.length, remaining: kept.length };
+}
+
+export async function clearTasks(cwd = process.cwd(), sessionId = '') {
+  await saveTasks([], cwd, sessionId);
+}

package/src/core/tools.js

@@ -0,0 +1,237 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { isDangerousCommand, runShellCommand } from './shell.js';
+import { evaluateCommandPolicy } from './command-policy.js';
+
+function resolveInWorkspace(root, targetPath = '.') {
+  const absRoot = path.resolve(root);
+  const absTarget = path.resolve(absRoot, targetPath);
+  if (!absTarget.startsWith(absRoot)) {
+    throw new Error(`Path escapes workspace: ${targetPath}`);
+  }
+  return absTarget;
+}
+
+async function readFile(root, args) {
+  const target = resolveInWorkspace(root, args?.path);
+  const stat = await fs.stat(target);
+  const text = await fs.readFile(target, 'utf8');
+  const lines = text.split('\n');
+  const totalLines = lines.length;
+  const startLineRaw = Number(args?.start_line);
+  const endLineRaw = Number(args?.end_line);
+  const defaultLines = Number(args?.default_lines || 220);
+  const maxChars = Number(args?.max_chars || 24000);
+  const includeContent = Boolean(args?.include_content);
+
+  let startLine = Number.isFinite(startLineRaw) && startLineRaw > 0 ? startLineRaw : 1;
+  let endLine =
+    Number.isFinite(endLineRaw) && endLineRaw >= startLine
+      ? endLineRaw
+      : Math.min(totalLines, startLine + Math.max(1, defaultLines) - 1);
+  startLine = Math.max(1, Math.min(startLine, totalLines));
+  endLine = Math.max(startLine, Math.min(endLine, totalLines));
+
+  const tokenSeed = `${args?.path}|${stat.size}|${stat.mtimeMs}|${startLine}|${endLine}`;
+  const readToken = crypto.createHash('sha1').update(tokenSeed).digest('hex').slice(0, 16);
+
+  if (!includeContent) {
+    return {
+      path: args?.path,
+      phase: 'metadata',
+      size_bytes: stat.size,
+      modified_at: new Date(stat.mtimeMs).toISOString(),
+      total_lines: totalLines,
+      suggested_start_line: startLine,
+      suggested_end_line: endLine,
+      read_token: readToken,
+      next: 'Call read_file again with include_content=true and this read_token'
+    };
+  }
+
+  if (String(args?.read_token || '') !== readToken) {
+    return {
+      path: args?.path,
+      phase: 'metadata',
+      error: 'read_token mismatch or missing',
+      size_bytes: stat.size,
+      modified_at: new Date(stat.mtimeMs).toISOString(),
+      total_lines: totalLines,
+      suggested_start_line: startLine,
+      suggested_end_line: endLine,
+      read_token: readToken,
+      next: 'Retry with include_content=true and read_token from latest metadata'
+    };
+  }
+
+  let content = lines.slice(startLine - 1, endLine).join('\n');
+  let truncated = false;
+  if (maxChars > 0 && content.length > maxChars) {
+    content = `${content.slice(0, maxChars)}\n... [truncated by max_chars]`;
+    truncated = true;
+  }
+
+  return {
+    path: args?.path,
+    phase: 'content',
+    start_line: startLine,
+    end_line: endLine,
+    total_lines: totalLines,
+    truncated,
+    content
+  };
+}
+
+async function writeFile(root, args) {
+  const rawPath = String(args?.path || '').trim();
+  if (!rawPath) {
+    throw new Error('write_file requires a file path like weather/WeatherForecast.js');
+  }
+  if (rawPath === '.' || rawPath === './') {
+    throw new Error('write_file requires a file path, not the workspace root');
+  }
+  const target = resolveInWorkspace(root, rawPath);
+  try {
+    const stat = await fs.stat(target);
+    if (stat.isDirectory()) {
+      throw new Error(`write_file target is a directory: ${rawPath}`);
+    }
+  } catch (error) {
+    if (error?.code && error.code !== 'ENOENT') {
+      throw error;
+    }
+  }
+  let before = '';
+  let existed = true;
+  try {
+    before = await fs.readFile(target, 'utf8');
+  } catch {
+    existed = false;
+  }
+  await fs.mkdir(path.dirname(target), { recursive: true });
+  if (args?.append) {
+    await fs.appendFile(target, args?.content || '', 'utf8');
+  } else {
+    await fs.writeFile(target, args?.content || '', 'utf8');
+  }
+  const after = args?.append ? `${before}${args?.content || ''}` : args?.content || '';
+  const beforeLines = before.split('\n');
+  const afterLines = after.split('\n');
+  let changeLine = 0;
+  const scanMax = Math.max(beforeLines.length, afterLines.length);
+  for (let i = 0; i < scanMax; i += 1) {
+    if ((beforeLines[i] || '') !== (afterLines[i] || '')) {
+      changeLine = i + 1;
+      break;
+    }
+  }
+  const previewStart = Math.max(0, (changeLine || 1) - 1);
+  const previewLines = afterLines.slice(previewStart, previewStart + 6);
+  return {
+    ok: true,
+    path: rawPath,
+    action: args?.append ? 'append' : existed ? 'overwrite' : 'create',
+    changed_line: changeLine || Math.max(1, afterLines.length),
+    diff_preview: previewLines.map((line, idx) => `${previewStart + idx + 1}| ${line}`).join('\n')
+  };
+}
+
+async function runCommand(root, config, args) {
+  const command = args?.command || '';
+  if (!command.trim()) {
+    throw new Error('run_command requires command');
+  }
+  if (
+    !config.policy.allow_dangerous_commands &&
+    isDangerousCommand(command, config.policy.blocked_command_patterns)
+  ) {
+    throw new Error('Command blocked by policy');
+  }
+
+  const check = evaluateCommandPolicy(command, config, root);
+  if (!check.allowed) {
+    throw new Error(
+      `Command blocked by safe mode: ${check.reason}${check.suggestion ? ` | ${check.suggestion}` : ''}`
+    );
+  }
+
+  const result = await runShellCommand({
+    command,
+    cwd: root,
+    shell: config.shell.default,
+    timeoutMs: config.shell.timeout_ms
+  });
+  return { ...result, command };
+}
+
+export function getBuiltinTools({ workspaceRoot = process.cwd(), config, sessionId = '' }) {
+  const definitions = [
+    {
+      type: 'function',
+      function: {
+        name: 'read_file',
+        description:
+          'Two-phase read: first call returns metadata+read_token; second call with include_content=true and matching read_token returns content',
+        parameters: {
+          type: 'object',
+          properties: {
+            path: { type: 'string' },
+            start_line: { type: 'number' },
+            end_line: { type: 'number' },
+            max_chars: { type: 'number' },
+            include_content: { type: 'boolean' },
+            read_token: { type: 'string' }
+          },
+          required: ['path']
+        }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'write_file',
+        description: 'Write a UTF-8 text file in workspace. Always provide a full file path, not a directory.',
+        parameters: {
+          type: 'object',
+          properties: {
+            path: { type: 'string' },
+            content: { type: 'string' },
+            append: { type: 'boolean' }
+          },
+          required: ['path', 'content']
+        }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'run_command',
+        description: 'Execute a shell command in workspace',
+        parameters: {
+          type: 'object',
+          properties: {
+            command: { type: 'string' }
+          },
+          required: ['command']
+        }
+      }
+    }
+  ];
+
+  const handlers = {
+    read_file: (args) =>
+      readFile(workspaceRoot, {
+        ...args,
+        default_lines: config.context?.read_file_default_lines ?? 220,
+        max_chars:
+          typeof args?.max_chars === 'number'
+            ? args.max_chars
+            : config.context?.read_file_max_chars ?? 24000
+      }),
+    write_file: (args) => writeFile(workspaceRoot, args),
+    run_command: (args) => runCommand(workspaceRoot, config, args)
+  };
+
+  return { definitions, handlers };
+}