codemini-cli 0.2.9 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemini-cli",
-  "version": "0.2.9",
+  "version": "0.3.1",
   "description": "Coding CLI optimized for small-model workflows and Windows PowerShell",
   "keywords": [
     "cli",

package/souls/anime.md

@@ -1,3 +1,14 @@
 Respond with a light anime-inspired tone.
-Keep the content useful and technically accurate, but add a playful, upbeat style.
-Do not overdo catchphrases, and do not let the style reduce clarity.
+
+Style guidelines:
+- Be cheerful and encouraging, like a helpful companion on an adventure.
+- Use occasional playful expressions (e.g. "好嘞，开干！", "搞定啦~", "Let's go!") but keep them natural and brief.
+- Add a touch of enthusiasm to progress updates and completions.
+- When something goes wrong, stay upbeat and frame it as a solvable challenge.
+- Use em dashes, tildes, or exclamation marks sparingly for personality.
+
+Boundaries:
+- Never sacrifice clarity, accuracy, or usefulness for style.
+- Do not overdo catchphrases, memes, or anime references.
+- Do not use this style as an excuse to be verbose — stay concise.
+- Technical terms, code, file paths, and command output must remain precise and unchanged.

package/souls/caveman.md

@@ -1,3 +1,13 @@
 Respond with a simple caveman-inspired tone.
-Keep sentences short, readable, and practical, while still preserving technical accuracy.
-Do not make the wording so primitive that instructions become unclear.
+
+Style guidelines:
+- Keep sentences short, punchy, and concrete.
+- Speak in direct, action-oriented phrases — "We fix bug. Code good now." style.
+- Use simple metaphors from the physical world (hunting, building, fire) when explaining concepts.
+- Celebrate successes with primal enthusiasm — "Bug crushed! Tribe safe."
+
+Boundaries:
+- Keep explanations readable and technically accurate.
+- Do not make wording so primitive that instructions or code suggestions become unclear.
+- Technical terms, code, file paths, and command output must remain precise and unchanged.
+- Never sacrifice correctness for the caveman gimmick.

package/souls/ceo.md

@@ -1,3 +1,14 @@
-Respond with a bold CEO-style tone.
-Keep the answer concise, forward-moving, and focused on fundamentals, tradeoffs, and execution.
-Do not imitate any real person, and do not let the style override careful technical judgment.
+Respond with a bold, decisive CEO-style tone.
+
+Style guidelines:
+- Speak with confidence and urgency — focus on what matters, cut the noise.
+- Frame every decision around impact, tradeoffs, and execution velocity.
+- Use executive phrasing: "Here's the play...", "The right call is...", "Let's ship this."
+- Acknowledge risks briefly, then commit to a clear direction.
+- Celebrate wins like closing a deal — "Clean execution. Moving on."
+
+Boundaries:
+- Do not imitate any real person or use cringe corporate buzzwords ("synergy", "paradigm shift").
+- Do not let the style override careful technical judgment — precision still wins.
+- Technical terms, code, file paths, and command output must remain precise and unchanged.
+- Stay concise — CEOs do not ramble.

package/souls/default.md

@@ -1,3 +1,11 @@
 Respond in a clear, calm, helpful tone.
-Be concise, friendly, and practical.
-Avoid roleplay, slang overload, or exaggerated personality.
+
+Style guidelines:
+- Be concise, friendly, and practical in every response.
+- Prioritize clarity and directness over embellishment.
+- Use simple, natural language — no forced personality or quirks.
+
+Boundaries:
+- Avoid roleplay, slang overload, or exaggerated personality.
+- Never sacrifice accuracy or usefulness for style.
+- Technical terms, code, file paths, and command output must remain precise and unchanged.

package/souls/pirate.md

@@ -1,3 +1,13 @@
-Respond with a playful pirate-inspired tone.
-Keep the answer clear, useful, and technically accurate first, with light nautical flavor.
-Do not overdo slang, and do not let the roleplay reduce precision.
+Respond with a playful pirate-inspired tone, matey.
+
+Style guidelines:
+- Use light nautical flavor and pirate expressions — "Aye", "Shiver me timbers", "Arrr", "Set sail".
+- Frame tasks as voyages and adventures — "Let's chart a course for that bug."
+- Celebrate successes like plundering treasure — "Shipshape! Bug walkin' the plank."
+- Keep the tone adventurous but grounded.
+
+Boundaries:
+- Keep the answer clear, useful, and technically accurate first, pirate flavor second.
+- Do not overdo slang — every sentence should still be understandable on first read.
+- Technical terms, code, file paths, and command output must remain precise and unchanged.
+- Never let roleplay reduce precision or hide important warnings.

package/souls/playful.md

@@ -1,3 +1,13 @@
-Respond with a witty and lively tone.
-Keep the answer readable and practical first, but allow a bit more personality and humor.
-Do not let humor obscure instructions or technical accuracy.
+Respond with a witty, lively, and slightly cheeky tone.
+
+Style guidelines:
+- Add personality and humor naturally — a well-placed quip or clever analogy goes a long way.
+- Use casual, conversational phrasing — "So here's the fun part...", "Plot twist:", "Easy fix incoming."
+- React to bugs and errors with good-natured humor — "Well, that's a creative way to break things."
+- Celebrate wins with flair — "Nailed it. Next?"
+
+Boundaries:
+- Keep the answer readable and practical first — humor is the seasoning, not the main dish.
+- Do not let jokes obscure instructions, warnings, or technical accuracy.
+- Technical terms, code, file paths, and command output must remain precise and unchanged.
+- Avoid sarcasm that could feel dismissive of the user's question.

package/souls/professional.md

@@ -1,3 +1,13 @@
-Respond in a polished, professional tone.
-Keep phrasing precise, confident, and concise.
-Prefer structured explanations over playful expression.
+Respond in a polished, professional, and authoritative tone.
+
+Style guidelines:
+- Keep phrasing precise, confident, and concise — like a senior engineer briefing a team.
+- Prefer structured explanations: numbered steps, clear headings, and logical flow.
+- State conclusions first, then back them up — lead with the answer, follow with reasoning.
+- Use measured, deliberate language — "The recommended approach is...", "This ensures..."
+
+Boundaries:
+- Prefer structured explanations over playful expression.
+- Avoid colloquialisms, emojis, or overly casual phrasing.
+- Technical terms, code, file paths, and command output must remain precise and unchanged.
+- Never pad responses with filler — every sentence should earn its place.

package/src/cli.js

@@ -3,8 +3,9 @@ import { handleRun } from './commands/run.js';
 import { handleConfig } from './commands/config.js';
 import { handleDoctor } from './commands/doctor.js';
 import { handleSkill } from './commands/skill.js';
+import pkg from '../package.json' with { type: 'json' };
 
-const VERSION = '0.2.9';
+const VERSION = pkg.version;
 
 function printHelp() {
   console.log(`codemini ${VERSION}

package/src/commands/chat.js

@@ -92,6 +92,7 @@ export async function handleChat(args) {
   const React = (await import('react')).default;
   const { render } = await import('ink');
   const { ChatApp } = await import('../tui/chat-app.js');
+
   const instance = render(
     React.createElement(ChatApp, {
       runtime,
@@ -103,5 +104,6 @@ export async function handleChat(args) {
       version: pkg.version
     })
   );
+
   await instance.waitUntilExit();
 }

package/src/core/agent-loop.js

@@ -1,6 +1,7 @@
 import os from 'node:os';
 import path from 'node:path';
 import fs from 'node:fs/promises';
+import { BoundedCache } from './bounded-cache.js';
 
 function safeJsonParse(raw) {
   if (!raw || typeof raw !== 'string') return {};
@@ -206,8 +207,16 @@ const TOOL_RESULTS_SUBDIR = 'tool-results';
 
 let currentResultDir = null;
 let resultDirReady = false;
-const storedResults = new Map(); // callId -> { filePath, summary }
-const readCache = new Map();     // "path:startLine:endLine:mtimeMs" -> true
+const storedResults = new BoundedCache({
+  maxSize: 64,
+  ttlMs: 30 * 60 * 1000,
+  onEvict(key, value) {
+    if (value?.filePath) {
+      fs.unlink(value.filePath).catch(() => {});
+    }
+  }
+}); // callId -> { filePath, summary }
+const readCache = new BoundedCache({ maxSize: 128, ttlMs: 10 * 60 * 1000 });   // "path:startLine:endLine:mtimeMs" -> true
 
 function generatePreview(content) {
   if (content.length <= PREVIEW_SIZE_BYTES) {
@@ -272,7 +281,7 @@ Summary: ${summary}
 
 export function clearResultStore() {
   const files = [];
-  for (const [, val] of storedResults) {
+  for (const [, val] of storedResults.entries()) {
     files.push(val.filePath);
   }
   storedResults.clear();
@@ -288,11 +297,6 @@ export function checkReadDedup(filePath, startLine, endLine, mtimeMs) {
     return true;
   }
   readCache.set(key, true);
-  // Keep cache bounded
-  if (readCache.size > 100) {
-    const firstKey = readCache.keys().next().value;
-    readCache.delete(firstKey);
-  }
   return false;
 }
 
@@ -406,6 +410,161 @@ export function trimInline(value, maxLen = 72) {
   return `${s.slice(0, maxLen - 3)}...`;
 }
 
+function normalizeAssistantText(value) {
+  return String(value || '').trim();
+}
+
+function hasTrailingToolContext(messages = []) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (!message || typeof message !== 'object') continue;
+    if (message.role === 'tool') return true;
+    if (message.role === 'assistant' || message.role === 'user') return false;
+  }
+  return false;
+}
+
+function isGenericCompletionText(text) {
+  const normalized = normalizeAssistantText(text).toLowerCase();
+  if (!normalized) return false;
+  const genericPhrases = new Set([
+    'done',
+    'completed',
+    'complete',
+    'finished',
+    'task completed',
+    'all done',
+    'ok',
+    'okay',
+    '已完成',
+    '已完成任务',
+    '完成',
+    '任务完成'
+  ]);
+  return genericPhrases.has(normalized);
+}
+
+function shouldAskForConcreteFinalAnswer(text, messages = []) {
+  if (!hasTrailingToolContext(messages)) return false;
+  const normalized = normalizeAssistantText(text);
+  if (!normalized) return true;
+  return isGenericCompletionText(normalized);
+}
+
+function isBroadRepositoryAnalysisTask(text) {
+  const normalized = String(text || '').trim().toLowerCase();
+  if (!normalized) return false;
+  return (
+    /optimi|improve|analy[sz]e|audit|review|overview|architecture|codebase|repository|repo/.test(normalized) ||
+    /项目.*优化|项目.*问题|可优化|分析这个项目|看看.*项目|代码库|仓库/.test(String(text || ''))
+  );
+}
+
+function parseProjectIndexSummary(text) {
+  const sourceRoots = [];
+  const entryCandidates = [];
+  const candidateFiles = [];
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('source_roots:')) {
+      sourceRoots.push(
+        ...String(trimmed.slice('source_roots:'.length))
+          .split(',')
+          .map((value) => value.trim())
+          .filter(Boolean)
+      );
+    } else if (trimmed.startsWith('entry_candidates:')) {
+      entryCandidates.push(
+        ...String(trimmed.slice('entry_candidates:'.length))
+          .split(',')
+          .map((value) => value.trim())
+          .filter(Boolean)
+      );
+    } else if (trimmed.startsWith('- ')) {
+      const match = trimmed.match(/^- ([^ ]+)/);
+      if (match?.[1]) candidateFiles.push(match[1].trim());
+    }
+  }
+  return { sourceRoots, entryCandidates, candidateFiles };
+}
+
+function createAnalysisGuardState(userPrompt) {
+  return {
+    active: isBroadRepositoryAnalysisTask(userPrompt),
+    indexQueried: false,
+    sourceRoots: new Set(),
+    entryCandidates: new Set(),
+    candidateFiles: new Set(),
+    relevantSourceReads: new Set(),
+    blockedExplorations: 0
+  };
+}
+
+function topLevelPath(value) {
+  const normalized = String(value || '').replace(/\\/g, '/').replace(/^\.\/+/, '').trim();
+  return normalized.split('/')[0] || '';
+}
+
+function isRelevantSourcePath(filePath, state) {
+  const normalized = String(filePath || '').replace(/\\/g, '/').trim();
+  if (!normalized) return false;
+  if (state.candidateFiles.has(normalized) || state.entryCandidates.has(normalized)) return true;
+  for (const root of state.sourceRoots) {
+    if (normalized === root || normalized.startsWith(`${root}/`)) return true;
+  }
+  return false;
+}
+
+function blockedExplorationReason(toolName, args, state) {
+  if (!state.active) return '';
+  if (!state.indexQueried && toolName !== 'query_project_index') {
+    return 'Use query_project_index before broad repository exploration so the next reads stay focused on relevant source files.';
+  }
+
+  const target = String(args?.path || args?.pattern || args?.query || '').replace(/\\/g, '/').trim();
+  const top = topLevelPath(target);
+  if (!top) return '';
+
+  if (['skills', 'souls', 'templates', '.codemini', '.codemini-project'].includes(top)) {
+    return `Skip ${top}/ for broad repository analysis unless the user explicitly asks for it. Inspect relevant source files first.`;
+  }
+  if (top === 'tests' && state.relevantSourceReads.size < 2) {
+    return 'Inspect the next relevant source files before reading tests. Broad analysis should be grounded in production code first.';
+  }
+  return '';
+}
+
+function noteAnalysisEvidence(state, toolName, args, toolResult) {
+  if (!state.active) return;
+  if (toolName === 'query_project_index') {
+    state.indexQueried = true;
+    const summary = parseProjectIndexSummary(JSON.stringify(toolResult));
+    for (const root of summary.sourceRoots) state.sourceRoots.add(root);
+    for (const entry of summary.entryCandidates) state.entryCandidates.add(entry);
+    for (const file of summary.candidateFiles) state.candidateFiles.add(file);
+    const projectMap = toolResult?.project_map || {};
+    for (const root of projectMap.source_roots || []) state.sourceRoots.add(String(root));
+    for (const entry of projectMap.entry_candidates || []) state.entryCandidates.add(String(entry));
+    for (const match of toolResult?.matches || []) {
+      if (match?.file) state.candidateFiles.add(String(match.file));
+    }
+    return;
+  }
+
+  if (toolName === 'read') {
+    const filePath = String(toolResult?.path || args?.path || '').split(':')[0];
+    if (isRelevantSourcePath(filePath, state)) {
+      state.relevantSourceReads.add(filePath);
+    }
+  }
+}
+
+function needsMoreAnalysisEvidence(state) {
+  if (!state.active) return false;
+  if (!state.indexQueried) return true;
+  return state.relevantSourceReads.size < 2;
+}
+
 function normalizeToolCallName(name) {
   return String(name || '').trim();
 }
@@ -509,6 +668,8 @@ export async function runAgentLoop({
 
   let finalText = '';
   let lastAssistantText = '';
+  let pendingSummaryNudges = 0;
+  const analysisGuard = createAnalysisGuardState(userPrompt);
   const alwaysAllowSet = new Set((Array.isArray(alwaysAllowTools) ? alwaysAllowTools : []).map((t) => String(t)));
 
   // Mutable tool list — grows as tool_search loads deferred tools
@@ -522,6 +683,10 @@ export async function runAgentLoop({
       tools: activeTools
     });
 
+    if (completion?.incomplete) {
+      continue;
+    }
+
     const toolCalls = Array.isArray(completion.toolCalls) ? completion.toolCalls : [];
     const assistantText = completion.text || '';
     lastAssistantText = assistantText || lastAssistantText;
@@ -546,10 +711,30 @@ export async function runAgentLoop({
     }
 
     if (toolCalls.length === 0) {
+      if (needsMoreAnalysisEvidence(analysisGuard) && pendingSummaryNudges < 2) {
+        pendingSummaryNudges += 1;
+        messages.push({
+          role: 'user',
+          content:
+            'You have not inspected enough relevant source files yet. Query the project index if needed, then inspect the next relevant source files before concluding. Do not stop after unrelated directories, tests, skills, souls, or templates.'
+        });
+        continue;
+      }
+      if (shouldAskForConcreteFinalAnswer(assistantText, messages.slice(0, -1)) && pendingSummaryNudges < 2) {
+        pendingSummaryNudges += 1;
+        messages.push({
+          role: 'user',
+          content:
+            'You have already inspected tool results. Before stopping, check whether the task is actually complete. If it is, provide a concise final answer with specific findings or concrete next steps. If it is not, continue with the next tool call.'
+        });
+        continue;
+      }
       finalText = assistantText;
       return { text: finalText, messages, steps: step + 1 };
     }
 
+    pendingSummaryNudges = 0;
+
     if (executionMode === 'plan') {
       const plannedLines = callsToPlanSummary(toolCalls);
       finalText = [
@@ -615,6 +800,20 @@ export async function runAgentLoop({
         throw new Error(`Unknown tool: ${call.name}`);
       }
 
+      const blockedReason = blockedExplorationReason(toolName, args, analysisGuard);
+      if (blockedReason) {
+        analysisGuard.blockedExplorations += 1;
+        const content = clipToolResult({ error: blockedReason }, toolResultMaxChars);
+        if (onEvent) {
+          onEvent({ type: 'tool:error', name: displayName, id: call.id, arguments: args, durationMs: 0, summary: trimInline(blockedReason, 120) });
+        }
+        return {
+          callId: call.id,
+          content,
+          error: true
+        };
+      }
+
       let toolResult;
       try {
         toolResult = await handler(args);
@@ -638,6 +837,7 @@ export async function runAgentLoop({
 
       // P1b: Use per-tool formatter if available, else fallback
       let formatted = formatToolResult(toolResult, toolName, args, toolFormatters, toolResultMaxChars);
+      noteAnalysisEvidence(analysisGuard, toolName, args, toolResult);
 
       // P2: If tool_search loaded deferred tools, inject their schemas into activeTools
       if (toolName === 'tool_search' && toolResult && Array.isArray(toolResult.schemas)) {

package/src/core/ast.js

@@ -1,8 +1,9 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import crypto from 'node:crypto';
 import { createRequire } from 'node:module';
 import { Parser, Language, Query } from 'web-tree-sitter';
+import { LANGUAGE_ALIASES, EXTENSION_LANGUAGE_MAP } from './constants.js';
+import { sha256Prefixed as sha256 } from './crypto-utils.js';
 
 const require = createRequire(import.meta.url);
 
@@ -20,56 +21,6 @@ const WRAPPER_NODE_TYPES = new Set([
   'template_function',
   'template_type'
 ]);
-const LANGUAGE_ALIASES = {
-  javascript: 'js',
-  js: 'js',
-  jsx: 'js',
-  typescript: 'ts',
-  ts: 'ts',
-  tsx: 'tsx',
-  python: 'python',
-  py: 'python',
-  go: 'go',
-  c: 'c',
-  cpp: 'cpp',
-  'c++': 'cpp',
-  bash: 'bash',
-  sh: 'bash',
-  shell: 'bash',
-  java: 'java',
-  rust: 'rust',
-  rs: 'rust',
-  csharp: 'csharp',
-  'c#': 'csharp',
-  cs: 'csharp',
-  php: 'php',
-  ruby: 'ruby',
-  rb: 'ruby'
-};
-const EXTENSION_LANGUAGE_MAP = {
-  '.js': 'js',
-  '.jsx': 'js',
-  '.mjs': 'js',
-  '.cjs': 'js',
-  '.ts': 'ts',
-  '.tsx': 'tsx',
-  '.py': 'python',
-  '.go': 'go',
-  '.c': 'c',
-  '.h': 'c',
-  '.cpp': 'cpp',
-  '.cc': 'cpp',
-  '.cxx': 'cpp',
-  '.hpp': 'cpp',
-  '.hh': 'cpp',
-  '.java': 'java',
-  '.rs': 'rust',
-  '.cs': 'csharp',
-  '.php': 'php',
-  '.rb': 'ruby',
-  '.sh': 'bash',
-  '.bash': 'bash'
-};
 const LANGUAGE_WASM_PATHS = {
   js: require.resolve('@cursorless/tree-sitter-wasms/out/tree-sitter-javascript.wasm'),
   ts: require.resolve('@cursorless/tree-sitter-wasms/out/tree-sitter-typescript.wasm'),
@@ -94,10 +45,6 @@ const parserInitPromise = Parser.init({
 });
 const languageCache = new Map();
 
-function sha256(input) {
-  return `sha256:${crypto.createHash('sha256').update(String(input || '')).digest('hex')}`;
-}
-
 function clipText(text, maxLen = 220) {
   const normalized = String(text || '').replace(/\s+/g, ' ').trim();
   if (normalized.length <= maxLen) return normalized;

package/src/core/bounded-cache.js

@@ -0,0 +1,121 @@
+/**
+ * 有限大小 + TTL 的 Map 缓存，带主动清理和可选的 onEvict 钩子。
+ * 用于替代无界 Map 以防止长时间运行时的内存泄漏。
+ */
+
+const DEFAULT_MAX_SIZE = 128;
+const DEFAULT_TTL_MS = 10 * 60 * 1000; // 10 分钟
+
+export class BoundedCache {
+  constructor(options = {}) {
+    this._maxSize = options.maxSize ?? DEFAULT_MAX_SIZE;
+    this._ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    this._onEvict = options.onEvict ?? null;
+    this._map = new Map();
+  }
+
+  get(key) {
+    const entry = this._map.get(key);
+    if (!entry) return undefined;
+    if (this._expired(entry)) {
+      this._removeEntry(key, entry);
+      return undefined;
+    }
+    return entry.value;
+  }
+
+  has(key) {
+    return this.get(key) !== undefined;
+  }
+
+  set(key, value) {
+    if (this._map.has(key)) {
+      const old = this._map.get(key);
+      if (this._onEvict && old !== undefined) {
+        try { this._onEvict(key, old.value); } catch {}
+      }
+      this._map.delete(key);
+    }
+    this._map.set(key, { value, ts: Date.now() });
+    this._evict();
+  }
+
+  delete(key) {
+    const entry = this._map.get(key);
+    if (!entry) return false;
+    this._removeEntry(key, entry);
+    return true;
+  }
+
+  clear() {
+    if (this._onEvict) {
+      for (const [key, entry] of this._map) {
+        try { this._onEvict(key, entry.value); } catch {}
+      }
+    }
+    this._map.clear();
+  }
+
+  get size() {
+    this._prune();
+    return this._map.size;
+  }
+
+  keys() {
+    this._prune();
+    return this._map.keys();
+  }
+
+  values() {
+    this._prune();
+    const out = [];
+    for (const entry of this._map.values()) {
+      out.push(entry.value);
+    }
+    return out;
+  }
+
+  entries() {
+    this._prune();
+    const out = [];
+    for (const [key, entry] of this._map.entries()) {
+      out.push([key, entry.value]);
+    }
+    return out;
+  }
+
+  // ─── 内部方法 ──────────────────────────────────────────────────────
+
+  _expired(entry) {
+    return Date.now() - entry.ts > this._ttlMs;
+  }
+
+  _removeEntry(key, entry) {
+    this._map.delete(key);
+    if (this._onEvict) {
+      try { this._onEvict(key, entry.value); } catch {}
+    }
+  }
+
+  /** 清理所有过期条目 */
+  _prune() {
+    for (const [key, entry] of this._map) {
+      if (this._expired(entry)) {
+        this._removeEntry(key, entry);
+      }
+    }
+  }
+
+  /** 按数量裁剪最旧的条目 */
+  _evict() {
+    this._prune();
+    if (this._map.size <= this._maxSize) return;
+    const iter = this._map.keys();
+    while (this._map.size > this._maxSize) {
+      const oldest = iter.next().value;
+      if (oldest === undefined) break;
+      const entry = this._map.get(oldest);
+      this._removeEntry(oldest, entry);
+    }
+  }
+}