codemini-cli 0.4.0 → 0.4.2

package/src/core/memory-store.js

@@ -41,22 +41,92 @@ async function ensureParent(filePath) {
 function buildFilePath(scope, workspaceRoot = process.cwd(), projectAlias = '') {
   if (scope === 'user') return path.join(getMemoryDir(), 'user.json');
   if (scope === 'global') return path.join(getMemoryDir(), 'global.json');
-  return path.join(getProjectMemoryDir(workspaceRoot), `${getProjectMemoryKey(workspaceRoot, projectAlias)}.json`);
+  return path.join(getProjectMemoryDir(workspaceRoot), 'project.json');
+}
+
+async function listProjectMemoryFiles(workspaceRoot = process.cwd()) {
+  const dir = getProjectMemoryDir(workspaceRoot);
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    return entries
+      .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+      .map((entry) => path.join(dir, entry.name))
+      .sort();
+  } catch {
+    return [];
+  }
 }
 
 async function readMemoryBucket(filePath) {
+  const doc = await readMemoryBucketDocument(filePath);
+  return doc.items;
+}
+
+async function readMemoryBucketDocument(filePath) {
   try {
     const raw = await fs.readFile(filePath, 'utf8');
     const parsed = JSON.parse(raw);
-    return Array.isArray(parsed?.items) ? parsed.items : [];
+    return {
+      items: Array.isArray(parsed?.items) ? parsed.items : [],
+      maintenance: parsed?.maintenance && typeof parsed.maintenance === 'object' ? parsed.maintenance : null
+    };
   } catch {
-    return [];
+    return { items: [], maintenance: null };
   }
 }
 
-async function writeMemoryBucket(filePath, items) {
+function memoryBucketHash(items = []) {
+  const stable = (Array.isArray(items) ? items : [])
+    .map((item) => ({
+      id: String(item?.id || ''),
+      kind: String(item?.kind || ''),
+      content: normalizeMemoryText(item?.content || ''),
+      summary: normalizeMemoryText(item?.summary || ''),
+      lifecycle: String(item?.lifecycle || ''),
+      pinned: item?.pinned === true
+    }))
+    .sort((left, right) => left.id.localeCompare(right.id));
+  return sha256(JSON.stringify(stable));
+}
+
+async function writeMemoryBucket(filePath, items, { maintenance = null } = {}) {
   await ensureParent(filePath);
-  await fs.writeFile(filePath, `${JSON.stringify({ items }, null, 2)}\n`, 'utf8');
+  const doc = { items };
+  if (maintenance) doc.maintenance = maintenance;
+  await fs.writeFile(filePath, `${JSON.stringify(doc, null, 2)}\n`, 'utf8');
+}
+
+function dedupeMemoryItems(items = []) {
+  const deduped = [];
+  const seen = new Set();
+  for (const item of items) {
+    const key = item.id ? `id:${item.id}` : `${item.kind}:${normalizeMemoryText(item.content)}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(item);
+  }
+  return deduped;
+}
+
+async function readProjectMemoryItems(workspaceRoot = process.cwd(), projectAlias = '') {
+  const projectKey = getProjectMemoryKey(workspaceRoot, projectAlias);
+  const files = await listProjectMemoryFiles(workspaceRoot);
+  const items = [];
+  for (const file of files) {
+    const bucket = await readMemoryBucket(file);
+    items.push(...bucket.map((item) => normalizeMemoryItem(item, 'project', projectKey)));
+  }
+  return dedupeMemoryItems(items)
+    .sort((left, right) => String(right.updatedAt).localeCompare(String(left.updatedAt)));
+}
+
+async function readScopeMemoryItems(scope, workspaceRoot = process.cwd(), projectAlias = '') {
+  const normalizedScope = ensureScope(scope);
+  if (normalizedScope === 'project') return readProjectMemoryItems(workspaceRoot, projectAlias);
+  const filePath = buildFilePath(normalizedScope, workspaceRoot, projectAlias);
+  return (await readMemoryBucket(filePath))
+    .map((item) => normalizeMemoryItem(item, normalizedScope, ''))
+    .sort((left, right) => String(right.updatedAt).localeCompare(String(left.updatedAt)));
 }
 
 function normalizeMemoryItem(item, scope, projectKey = '') {
@@ -74,7 +144,8 @@ function normalizeMemoryItem(item, scope, projectKey = '') {
     createdAt: String(item?.createdAt || now),
     updatedAt: String(item?.updatedAt || now),
     hits: Number.isFinite(Number(item?.hits)) ? Number(item.hits) : 0,
-    pinned: item?.pinned === true
+    pinned: item?.pinned === true,
+    ...(item?.lifecycle ? { lifecycle: String(item.lifecycle) } : {})
   };
 }
 
@@ -96,13 +167,69 @@ function budgetForScope(scope, config = {}) {
 }
 
 export async function listMemories({ scope, workspaceRoot = process.cwd(), projectAlias = '' }) {
+  const normalizedScope = ensureScope(scope);
+  return readScopeMemoryItems(normalizedScope, workspaceRoot, projectAlias);
+}
+
+export async function getMemoryBucketMaintenance({ scope, workspaceRoot = process.cwd(), projectAlias = '' }) {
+  const normalizedScope = ensureScope(scope);
+  const filePath = buildFilePath(normalizedScope, workspaceRoot, projectAlias);
+  const doc = await readMemoryBucketDocument(filePath);
+  const items = normalizedScope === 'project'
+    ? await readProjectMemoryItems(workspaceRoot, projectAlias)
+    : doc.items.map((item) => normalizeMemoryItem(item, normalizedScope, ''));
+  const currentHash = memoryBucketHash(items);
+  const storedHash = String(doc.maintenance?.contentHash || '');
+  const maintainedAt = String(doc.maintenance?.maintainedAt || '');
+  return {
+    scope: normalizedScope,
+    itemCount: items.length,
+    contentHash: currentHash,
+    storedHash,
+    maintainedAt,
+    fresh: Boolean(maintainedAt && storedHash && storedHash === currentHash)
+  };
+}
+
+export async function markMemoryBucketMaintained({ scope, workspaceRoot = process.cwd(), projectAlias = '' }) {
+  const normalizedScope = ensureScope(scope);
+  const filePath = buildFilePath(normalizedScope, workspaceRoot, projectAlias);
+  const items = await readScopeMemoryItems(normalizedScope, workspaceRoot, projectAlias);
+  const maintenance = {
+    maintainedAt: nowIso(),
+    contentHash: memoryBucketHash(items),
+    itemCount: items.length
+  };
+  await writeMemoryBucket(filePath, items, { maintenance });
+  return { scope: normalizedScope, ...maintenance };
+}
+
+export async function replaceMemoryBucket({
+  scope,
+  items = [],
+  workspaceRoot = process.cwd(),
+  projectAlias = '',
+  markMaintained = false
+} = {}) {
   const normalizedScope = ensureScope(scope);
   const filePath = buildFilePath(normalizedScope, workspaceRoot, projectAlias);
   const projectKey = normalizedScope === 'project' ? getProjectMemoryKey(workspaceRoot, projectAlias) : '';
-  const items = await readMemoryBucket(filePath);
-  return items
+  const normalizedItems = (Array.isArray(items) ? items : [])
     .map((item) => normalizeMemoryItem(item, normalizedScope, projectKey))
-    .sort((left, right) => String(right.updatedAt).localeCompare(String(left.updatedAt)));
+    .filter((item) => item.content);
+  const maintenance = markMaintained
+    ? {
+        maintainedAt: nowIso(),
+        contentHash: memoryBucketHash(normalizedItems),
+        itemCount: normalizedItems.length
+      }
+    : null;
+  await writeMemoryBucket(filePath, normalizedItems, { maintenance });
+  return {
+    scope: normalizedScope,
+    items: normalizedItems,
+    maintenance
+  };
 }
 
 export async function rememberMemory({
@@ -125,7 +252,7 @@ export async function rememberMemory({
 
   const filePath = buildFilePath(normalizedScope, workspaceRoot, projectAlias);
   const projectKey = normalizedScope === 'project' ? getProjectMemoryKey(workspaceRoot, projectAlias) : '';
-  const existing = (await readMemoryBucket(filePath)).map((item) => normalizeMemoryItem(item, normalizedScope, projectKey));
+  const existing = await readScopeMemoryItems(normalizedScope, workspaceRoot, projectAlias);
   const probe = normalizeMemoryItem({ content: normalizedContent, kind, summary, source, confidence, pinned }, normalizedScope, projectKey);
 
   const replaceIndex = replaceSimilar ? existing.findIndex((item) => sameMemory(item, probe)) : -1;
@@ -170,6 +297,14 @@ export async function forgetMemory({ scope, id, workspaceRoot = process.cwd(), p
   const existing = await listMemories({ scope: normalizedScope, workspaceRoot, projectAlias });
   const kept = existing.filter((item) => item.id !== id);
   await writeMemoryBucket(filePath, kept);
+  if (normalizedScope === 'project') {
+    const files = (await listProjectMemoryFiles(workspaceRoot)).filter((file) => file !== filePath);
+    await Promise.all(files.map(async (file) => {
+      const bucket = await readMemoryBucket(file);
+      const next = bucket.filter((item) => String(item?.id || '') !== id);
+      if (next.length !== bucket.length) await writeMemoryBucket(file, next);
+    }));
+  }
   return { removed: existing.length - kept.length };
 }
 

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

@@ -54,6 +54,36 @@ async function parseJsonResponse(response) {
   return response.json();
 }
 
+function isRetryableStatus(status) {
+  return status === 408 || status === 409 || status === 425 || status === 429 || status >= 500;
+}
+
+function isRetryableError(error) {
+  const name = String(error?.name || '');
+  if (name === 'AbortError' || name === 'TimeoutError') return false;
+  const message = String(error?.message || error || '');
+  return /fetch failed|network|socket|ECONNRESET|ETIMEDOUT|EAI_AGAIN/i.test(message);
+}
+
+async function fetchWithRetry(url, init, { maxRetries = 0 } = {}) {
+  const attempts = Math.max(0, Number(maxRetries) || 0) + 1;
+  let lastError;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    try {
+      const response = await fetch(url, init);
+      if (response.ok || !isRetryableStatus(response.status) || attempt === attempts - 1) {
+        return response;
+      }
+      await response.arrayBuffer().catch(() => null);
+    } catch (error) {
+      lastError = error;
+      if (!isRetryableError(error) || attempt === attempts - 1) throw error;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50 * (attempt + 1)));
+  }
+  throw lastError || new Error('Gateway request failed');
+}
+
 async function* iterateSseEvents(stream) {
   const decoder = new TextDecoder();
   let buffer = '';
@@ -318,12 +348,12 @@ export async function createChatCompletion({
   maxRetries = 2
 }) {
   const payload = buildPayload({ model, temperature, messages, tools });
-  const response = await fetch(buildChatCompletionsUrl(baseUrl), {
+  const response = await fetchWithRetry(buildChatCompletionsUrl(baseUrl), {
     method: 'POST',
     headers: createHeaders(apiKey),
     body: JSON.stringify(payload),
     signal: AbortSignal.timeout(timeoutMs)
-  });
+  }, { maxRetries });
   const data = await parseJsonResponse(response);
   const message = data?.choices?.[0]?.message || {};
   const text = sanitizeMiniMaxText(model, extractTextContent(message.content));
@@ -386,12 +416,12 @@ export async function createChatCompletionStream({
     }
   }
   const payload = buildPayload({ model, temperature, messages, tools, stream: true });
-  const response = await fetch(buildChatCompletionsUrl(baseUrl), {
+  const response = await fetchWithRetry(buildChatCompletionsUrl(baseUrl), {
     method: 'POST',
     headers: createHeaders(apiKey),
     body: JSON.stringify(payload),
     signal: controller.signal
-  });
+  }, { maxRetries });
   if (!response.ok || !response.body) {
     const text = await response.text().catch(() => '');
     throw new Error(`Gateway error ${response.status}: ${text || response.statusText}`);
@@ -402,7 +432,8 @@ export async function createChatCompletionStream({
   let usage = null;
   let miniMaxStreamState = { rawContent: '', visibleText: '' };
 
-  for await (const chunk of iterateSseEvents(response.body)) {
+  try {
+    for await (const chunk of iterateSseEvents(response.body)) {
     usage = chunk?.usage || usage;
     const choice0 = chunk?.choices?.[0] || {};
     const delta = choice0?.delta || {};
@@ -452,6 +483,10 @@ export async function createChatCompletionStream({
     if (choice0?.finish_reason) {
       break;
     }
+    }
+  } finally {
+    timeoutSignal.removeEventListener('abort', onAbort);
+    if (externalSignal) externalSignal.removeEventListener('abort', onAbort);
   }
 
   const result = buildFinalStreamResult(text, toolCallsByIndex, usage, messages);

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-profile.js

@@ -146,11 +146,11 @@ export function getShellSystemPrompt(value) {
 ALWAYS prefer dedicated tools over raw shell commands:
 - The visible default tool list is intentionally small. If a needed capability is not currently listed, do not assume it is unavailable — call tool_search to load additional tools first
 - Use query_project_index first for broad repository understanding. It combines project-map metadata with indexed file symbols so you can narrow candidates before reading source files
-- Use read to inspect files — NEVER use cat, head, or tail via run. read returns content directly by default; demo-style shapes like {file_path:"src/app.ts"}, {path:"src/app.ts:10-40"}, or {file_path:"src/app.ts", offset:10, limit:30} are accepted
+- Use read to inspect files — NEVER use cat, head, or tail via run. Use canonical shapes like {path:"src/app.ts"}, {path:"src/app.ts:10-40"}, or {path:"src/app.ts", start_line:10, end_line:40}
 - Use grep to search file contents — NEVER use grep or rg via run
 - Use list for directory-by-directory filesystem discovery. If you specifically need pattern-based file lookup like src/**/*.ts, load glob with tool_search instead of falling back to run
-- Use edit to modify existing files — this is the DEFAULT path for code changes. Demo-style aliases like {file_path:"src/app.ts", old_string:"foo", new_string:"bar"} are accepted
-- Use write only for creating new files or complete rewrites (set full_file_rewrite=true for existing code files). Aliases like {file:"notes.txt", text:"..."} are accepted
+- Use edit to modify existing files — this is the DEFAULT path for code changes. Prefer {path:"src/app.ts", old_text:"foo", new_text:"bar"}
+- Use write only for creating new files or complete rewrites (set full_file_rewrite=true for existing code files). Prefer {path:"notes.txt", content:"..."}
 - Use update_todos to manage the session todo checklist for complex work. Provide the full current list each time and usually keep exactly one item in_progress
 - Use read_plan and update_plan to recover or sync structured plan state when plan progress was interrupted (for example by transient gateway/model errors)
 - Use run for shell commands. For long-running processes (dev servers, watchers), set run_in_background=true when you know you do not need the final result immediately. Long-running commands may also be backgrounded automatically
@@ -181,15 +181,15 @@ For background commands: use run to launch. If you need management tools that ar
 Common tool call patterns:
 - Query the project index first: {query:"login auth flow", path:"src", max_results:5}
 - Load a deferred tool when needed: {query:"glob"} or {query:"all"}
-- Read a file: {path:"src/app.ts"} or {file_path:"src/app.ts", offset:20, limit:40}
+- Read a file: {path:"src/app.ts"} or {path:"src/app.ts", start_line:20, end_line:60}
 - Read a specific range inline: {path:"src/app.ts:20-60"}
 - Search text: {pattern:"loginUser", path:"src"} or {query:"loginUser", directory:"src"}
 - List a directory first: {path:"src"}
 - After loading glob, find files by pattern: {pattern:"src/**/*.ts"} or {query:"src/**/*.ts"}
-- Edit exact text: {file_path:"src/app.ts", old_string:"foo", new_string:"bar"}
+- Edit exact text: {path:"src/app.ts", old_text:"foo", new_text:"bar"}
 - Edit with shorthand: {path:"src/app.ts", old_text:"foo", content:"bar"}
-- Write a new file: {file:"notes.txt", text:"..."} or {path:"src/page.tsx", content:"..."}
-- When the environment provides a Working directory, prefer absolute file_path values rooted there instead of guessing prefixes
+- Write a new file: {path:"notes.txt", content:"..."} or {path:"src/page.tsx", content:"..."}
+- When the environment provides a Working directory, prefer absolute path values rooted there instead of guessing prefixes
 - If the user gives a relative path like src/app.ts, resolve it from the current Working directory rather than inventing ../ or sibling folders
 
 # Doing tasks
@@ -218,7 +218,7 @@ Common tool call patterns:
 - Keep answers compact and easy to scan
 - Lead with the answer or next action, not scene-setting
 - Do not restate the user's request unless a brief restatement prevents ambiguity
-- When referencing code, use file_path:line_number format
+- When referencing code, use path:line_number format
 - Keep technical wording, commands, paths, and error details exact
 - Only use emojis if the user explicitly requests it`;
 }