codemini-cli 0.4.1 → 0.4.3

package/src/core/provider/anthropic.js

@@ -294,7 +294,7 @@ export async function createChatCompletion({
   messages,
   temperature = 0.2,
   tools,
-  timeoutMs = 90000,
+  timeoutMs = 1800000,
   maxTokens = 4096
 }) {
   const payload = buildPayload({ model, temperature, messages, tools, maxTokens });
@@ -317,7 +317,7 @@ export async function createChatCompletionStream({
   tools,
   onTextDelta,
   onToolCallDelta,
-  timeoutMs = 90000,
+  timeoutMs = 1800000,
   maxTokens = 4096,
   signal: externalSignal
 }) {

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

@@ -344,7 +344,7 @@ export async function createChatCompletion({
   messages,
   temperature = 0.2,
   tools,
-  timeoutMs = 90000,
+  timeoutMs = 1800000,
   maxRetries = 2
 }) {
   const payload = buildPayload({ model, temperature, messages, tools });
@@ -399,7 +399,7 @@ export async function createChatCompletionStream({
   tools,
   onTextDelta,
   onToolCallDelta,
-  timeoutMs = 90000,
+  timeoutMs = 1800000,
   maxRetries = 2,
   signal: externalSignal
 }) {

package/src/core/reflect-skill.js

@@ -0,0 +1,178 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getProjectSkillsDir, getSkillsDir } from './paths.js';
+import { createChatCompletion } from './provider/index.js';
+
+const REFLECT_TIMEOUT_MS = 45000;
+
+function slugifySkillName(value) {
+  const slug = String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9\u4e00-\u9fa5]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return slug || 'reflected-success-workflow';
+}
+
+function escapeFrontmatter(value) {
+  return String(value || '').replace(/\r?\n/g, ' ').replace(/"/g, '\\"').trim();
+}
+
+function hasFrontmatter(content) {
+  return /^---\r?\n[\s\S]*?\r?\n---\r?\n/.test(String(content || '').trimStart());
+}
+
+function renderSkillContent({ name, description, content }) {
+  const body = String(content || '').trim() || [
+    '## Workflow',
+    '',
+    '1. Recreate the successful chain from the recent task.',
+    '2. Preserve the key decision that made it work.',
+    '3. Verify with the narrowest relevant check.',
+    '',
+    '## Boundaries',
+    '',
+    'Use this only when the current task matches the preserved workflow.'
+  ].join('\n');
+  if (hasFrontmatter(body)) return `${body.trim()}\n`;
+  return [
+    '---',
+    `name: ${name}`,
+    `description: ${escapeFrontmatter(description) || `Use when this reflected workflow applies.`}`,
+    '---',
+    '',
+    body
+  ].join('\n').trimEnd() + '\n';
+}
+
+export function normalizeReflectDraft(raw = {}) {
+  const name = slugifySkillName(raw.name || raw.skillName || raw.title);
+  const description = String(raw.description || raw.summary || `Use when the ${name} workflow applies.`).trim();
+  const confidence = Math.min(1, Math.max(0, Number(raw.confidence ?? 0.75)));
+  return {
+    id: Number(raw.id || 1),
+    name,
+    description,
+    confidence,
+    content: renderSkillContent({ name, description, content: raw.content || raw.markdown || raw.body })
+  };
+}
+
+export function buildReflectTargetPath({ scope = 'project', name, workspaceRoot = process.cwd() } = {}) {
+  const safeName = slugifySkillName(name);
+  const baseDir = String(scope || '').toLowerCase() === 'global'
+    ? getSkillsDir()
+    : getProjectSkillsDir(workspaceRoot);
+  return path.join(baseDir, safeName, 'SKILL.md');
+}
+
+export function parseReflectScope(args = []) {
+  let scope = 'project';
+  const requestParts = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = String(args[index] || '');
+    if (arg === '--scope') {
+      const next = String(args[index + 1] || '').toLowerCase();
+      if (next === 'global' || next === 'project') {
+        scope = next;
+        index += 1;
+      }
+      continue;
+    }
+    if (arg.startsWith('--scope=')) {
+      const value = arg.slice('--scope='.length).toLowerCase();
+      if (value === 'global' || value === 'project') scope = value;
+      continue;
+    }
+    requestParts.push(arg);
+  }
+  return { scope, request: requestParts.join(' ').trim() };
+}
+
+function parseModelDrafts(text) {
+  const raw = String(text || '').trim();
+  if (!raw) return [];
+  const unfenced = raw.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, '').trim();
+  try {
+    const parsed = JSON.parse(unfenced);
+    if (Array.isArray(parsed?.candidates)) return parsed.candidates.map((item, index) => normalizeReflectDraft({ id: index + 1, ...item }));
+    if (Array.isArray(parsed)) return parsed.map((item, index) => normalizeReflectDraft({ id: index + 1, ...item }));
+    if (parsed && typeof parsed === 'object') return [normalizeReflectDraft(parsed)];
+  } catch {
+    // Fall back to wrapping plain markdown below.
+  }
+  return [normalizeReflectDraft({
+    name: 'reflected-success-workflow',
+    description: 'Use when the reflected successful workflow applies.',
+    content: raw
+  })];
+}
+
+function recentContext(session, limit = 10) {
+  const messages = Array.isArray(session?.messages) ? session.messages : [];
+  return messages
+    .slice(-limit)
+    .map((message) => `${message.role}: ${String(message.content || '').slice(0, 1200)}`)
+    .join('\n\n');
+}
+
+export async function buildReflectSkillDraft({
+  request = '',
+  scope = 'project',
+  session,
+  config = {},
+  model,
+  systemPrompt = '',
+  previousDraft = null,
+  feedback = ''
+} = {}) {
+  const mode = String(request || '').trim() ? 'directed' : 'exploratory';
+  const prompt = [
+    'Create a reusable Codex/CodeMini SKILL.md draft from a successful workflow.',
+    `Mode: ${mode}`,
+    `Target scope: ${scope}`,
+    request ? `User reflection request:\n${request}` : 'No explicit request was supplied. Be conservative and return no candidates if the recent context does not show a reusable success pattern.',
+    previousDraft ? `Existing draft to revise:\n${previousDraft.content || ''}` : '',
+    feedback ? `User edit feedback:\n${feedback}` : '',
+    'Recent session context:',
+    recentContext(session),
+    'Return valid JSON only, no markdown fences.',
+    'Shape: {"candidates":[{"name":"kebab-case-name","description":"when to use this skill","confidence":0.0,"content":"full SKILL.md body or markdown body"}]}',
+    'The content must include trigger conditions, workflow/toolchain, key decisions, pitfalls, verification, and boundaries.',
+    'Do not write memory or inbox content. This is only a skill draft.'
+  ].filter(Boolean).join('\n\n');
+
+  const result = await createChatCompletion({
+    sdkProvider: config?.sdk?.provider,
+    baseUrl: config?.gateway?.base_url,
+    apiKey: config?.gateway?.api_key,
+    model: model || config?.model?.name,
+    messages: [
+      { role: 'system', content: systemPrompt || 'You draft concise, reusable coding workflow skills.' },
+      { role: 'user', content: prompt }
+    ],
+    temperature: 0,
+    timeoutMs: REFLECT_TIMEOUT_MS
+  });
+
+  return parseModelDrafts(result?.text || '');
+}
+
+export function attachReflectTargets({ candidates = [], scope = 'project', workspaceRoot = process.cwd() } = {}) {
+  return candidates.map((candidate, index) => {
+    const draft = normalizeReflectDraft({ id: index + 1, ...candidate });
+    return {
+      ...draft,
+      targetPath: buildReflectTargetPath({ scope, name: draft.name, workspaceRoot })
+    };
+  });
+}
+
+export async function writeReflectSkillDraft({ draft, scope = 'project', workspaceRoot = process.cwd() } = {}) {
+  const normalized = normalizeReflectDraft(draft);
+  const filePath = buildReflectTargetPath({ scope, name: normalized.name, workspaceRoot });
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, normalized.content, 'utf8');
+  return { filePath, draft: normalized };
+}
+

package/src/core/shell.js

@@ -220,7 +220,7 @@ export function runShellCommand({
   command,
   cwd = process.cwd(),
   shell = 'powershell',
-  timeoutMs = 120000
+  timeoutMs = 1800000
 }) {
   const shellSpec = resolveShell(shell);
   const shellCommand =

package/src/core/tool-result-store.js

@@ -0,0 +1,206 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { BoundedCache } from './bounded-cache.js';
+import { trimInline } from './string-utils.js';
+
+const TOOL_RESULT_DISK_THRESHOLD = 6000;
+const PREVIEW_SIZE_BYTES = 2000;
+const TOOL_RESULTS_SUBDIR = 'tool-results';
+
+let currentResultDir = null;
+let resultDirReady = false;
+
+const storedResults = new BoundedCache({
+  maxSize: 64,
+  ttlMs: 30 * 60 * 1000,
+  onEvict(_key, value) {
+    if (value?.filePath) {
+      fs.unlink(value.filePath).catch(() => {});
+    }
+  }
+});
+
+const readCache = new BoundedCache({ maxSize: 128, ttlMs: 10 * 60 * 1000 });
+
+function generatePreview(content) {
+  if (content.length <= PREVIEW_SIZE_BYTES) {
+    return { preview: content, hasMore: false };
+  }
+  const truncated = content.slice(0, PREVIEW_SIZE_BYTES);
+  const lastNewline = truncated.lastIndexOf('\n');
+  const cutPoint = lastNewline > PREVIEW_SIZE_BYTES * 0.5 ? lastNewline : PREVIEW_SIZE_BYTES;
+  return { preview: content.slice(0, cutPoint), hasMore: true };
+}
+
+function formatFileSize(chars) {
+  if (chars < 1024) return `${chars} B`;
+  return `${(chars / 1024).toFixed(1)} KB`;
+}
+
+export function setResultDir(dir) {
+  currentResultDir = dir ? path.join(dir, TOOL_RESULTS_SUBDIR) : null;
+  resultDirReady = false;
+}
+
+async function ensureResultDir() {
+  if (!currentResultDir) return false;
+  if (!resultDirReady) {
+    await fs.mkdir(currentResultDir, { recursive: true });
+    resultDirReady = true;
+  }
+  return true;
+}
+
+export async function storeResultIfNeeded(callId, formattedContent, rawResult) {
+  if (formattedContent.length <= TOOL_RESULT_DISK_THRESHOLD) {
+    return formattedContent;
+  }
+  try {
+    const ready = await ensureResultDir();
+    const dir = ready ? currentResultDir : path.join(os.tmpdir(), 'codemini-results');
+    if (!resultDirReady && dir === currentResultDir) {
+      await fs.mkdir(dir, { recursive: true });
+    } else if (!resultDirReady) {
+      await fs.mkdir(dir, { recursive: true });
+    }
+    const filePath = path.join(dir, `${callId}.txt`);
+    const payload = typeof rawResult === 'string' ? rawResult : JSON.stringify(rawResult, null, 2);
+    await fs.writeFile(filePath, payload, 'utf-8');
+    const summary = summarizeToolResult(rawResult);
+    const { preview, hasMore } = generatePreview(payload);
+    storedResults.set(callId, { filePath, summary });
+
+    return `<persisted-output>
+Output too large (${formatFileSize(payload.length)}). Full output saved to: ${filePath}
+
+Preview (first ${formatFileSize(PREVIEW_SIZE_BYTES)}):
+${preview}${hasMore ? '\n...' : ''}
+
+Summary: ${summary}
+</persisted-output>`;
+  } catch {
+    return formattedContent;
+  }
+}
+
+export function clearResultStore() {
+  const files = [];
+  for (const [, val] of storedResults.entries()) {
+    files.push(val.filePath);
+  }
+  storedResults.clear();
+  readCache.clear();
+  return Promise.allSettled(files.map((filePath) => fs.unlink(filePath).catch(() => {})));
+}
+
+export function checkReadDedup(filePath, startLine, endLine, mtimeMs) {
+  const key = `${filePath}:${startLine || 0}:${endLine || 0}:${mtimeMs}`;
+  if (readCache.has(key)) {
+    return true;
+  }
+  readCache.set(key, true);
+  return false;
+}
+
+export function summarizeToolResult(result) {
+  if (result === null || result === undefined) return 'no output';
+  if (typeof result === 'string') {
+    const oneLine = result.replace(/\s+/g, ' ').trim();
+    return oneLine.length > 90 ? `${oneLine.slice(0, 87)}...` : oneLine || 'empty string';
+  }
+  if (typeof result === 'object') {
+    const obj = result;
+    if (Array.isArray(obj)) return `array(${obj.length})`;
+    if ('deleted' in obj && 'path' in obj) {
+      const kind = trimInline(obj.type || 'item', 16);
+      const target = trimInline(obj.path || '', 96);
+      if (obj.deleted) return target ? `deleted ${kind} ${target}` : `deleted ${kind}`;
+      if (obj.cancelled) return target ? `cancelled delete ${target}` : 'cancelled delete';
+    }
+    if ('path' in obj && 'action' in obj) {
+      const p = String(obj.path || '');
+      const action = String(obj.action || 'write');
+      const line = Number(obj.changed_line || 1);
+      const suffix =
+        action === 'delete'
+          ? 'deleted'
+          : action === 'create'
+            ? 'created'
+            : action === 'patch'
+              ? 'patched'
+              : action === 'replace_block' || action === 'replace_text'
+                ? 'edited'
+                : action === 'append'
+                  ? 'appended'
+                  : 'updated';
+      return p ? `${suffix} ${p}${line > 0 ? ` @L${line}` : ''}` : suffix;
+    }
+    if ('path' in obj && 'phase' in obj) {
+      const phase = String(obj.phase || '');
+      const p = String(obj.path || '');
+      const total = Number(obj.total_lines);
+      const start =
+        Number(obj.suggested_start_line || obj.start_line) > 0
+          ? Number(obj.suggested_start_line || obj.start_line)
+          : 1;
+      const end =
+        Number(obj.suggested_end_line || obj.end_line) >= start
+          ? Number(obj.suggested_end_line || obj.end_line)
+          : start;
+      const rangeText = start > 0 && end >= start ? ` lines ${start}-${end}` : '';
+      const totalText = total > 0 ? ` of ${total}` : '';
+      const enclosingText = obj.enclosing_symbol ? ` in ${obj.enclosing_symbol}` : '';
+      const errorText = obj.error ? ` (${trimInline(obj.error, 64)})` : '';
+      const truncatedText = obj.truncated ? ' [truncated]' : '';
+      return phase === 'metadata'
+        ? `metadata for ${p}${rangeText}${totalText}${errorText}`
+        : `content from ${p}${rangeText}${totalText}${enclosingText}${truncatedText}`;
+    }
+    if ('stdout' in obj || 'stderr' in obj || 'code' in obj) {
+      const stdout = trimInline(obj.stdout || '', 96);
+      const stderr = trimInline(obj.stderr || '', 96);
+      const command = trimInline(obj.command || '', 72);
+      const lead = command ? `${command} -> ` : '';
+      if (stdout) return `${lead}exit ${obj.code ?? 0}\nstdout: ${stdout}`;
+      if (stderr) return `${lead}exit ${obj.code ?? 0}\nstderr: ${stderr}`;
+      return `${lead}exit ${obj.code ?? 0}`;
+    }
+    if ('task_id' in obj && 'startup_confirmed' in obj) {
+      const status = trimInline(obj.status || 'unknown', 32);
+      const taskId = trimInline(obj.task_id || '', 24);
+      const source = trimInline(obj.startup_source || '', 24);
+      const outputFile = trimInline(obj.output_file || '', 72);
+      const output = Array.isArray(obj.recent_output) ? trimInline(obj.recent_output.slice(-1)[0] || '', 96) : '';
+      return `${taskId || 'task'} ${status}${source ? ` (${source})` : ''}${outputFile ? ` -> ${outputFile}` : ''}${output ? `\n${output}` : ''}`;
+    }
+    if ('tasks' in obj && Array.isArray(obj.tasks)) {
+      const count = obj.tasks.length;
+      const first = obj.tasks[0];
+      const lead = first?.task_id ? `${trimInline(first.task_id, 24)} ${trimInline(first.status || 'unknown', 24)}` : '';
+      return `tasks(${count})${lead ? `\n${lead}` : ''}`;
+    }
+    if ('files' in obj && Array.isArray(obj.files)) {
+      return `patched ${obj.files.length} file(s)`;
+    }
+    if ('diff' in obj && 'new_hash' in obj && 'path' in obj) {
+      const p = String(obj.path || '');
+      return p ? `diff preview for ${p}` : 'diff preview';
+    }
+    if ('created' in obj && Array.isArray(obj.created)) {
+      return `created ${obj.created.length} task(s)`;
+    }
+    if ('tasks' in obj && Array.isArray(obj.tasks)) {
+      return `${obj.tasks.length} task(s)`;
+    }
+    if ('newTodos' in obj && Array.isArray(obj.newTodos)) {
+      return obj.newTodos.length > 0 ? `updated ${obj.newTodos.length} todo item(s)` : 'cleared todo list';
+    }
+    if ('newPlan' in obj) {
+      return obj.newPlan ? `updated plan state (${String(obj.newPlan.status || 'draft')})` : 'cleared plan state';
+    }
+    const keys = Object.keys(obj);
+    return keys.length > 0 ? `keys: ${keys.slice(0, 5).join(',')}` : 'object';
+  }
+  return String(result);
+}