codemini-cli 0.2.7 → 0.2.9

package/package.json

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

package/src/cli.js

@@ -4,7 +4,7 @@ import { handleConfig } from './commands/config.js';
 import { handleDoctor } from './commands/doctor.js';
 import { handleSkill } from './commands/skill.js';
 
-const VERSION = '0.2.7';
+const VERSION = '0.2.9';
 
 function printHelp() {
   console.log(`codemini ${VERSION}

package/src/core/agent-loop.js

@@ -14,6 +14,101 @@ function safeJsonParse(raw) {
   }
 }
 
+function parseInlineRangePath(value) {
+  const text = String(value || '').trim();
+  if (!text) return null;
+  const match = text.match(/^(.*?):(\d+)(?:-(\d+))?$/);
+  if (!match) return null;
+  const [, maybePath, startRaw, endRaw] = match;
+  if (!maybePath || /^(?:[A-Za-z])$/.test(maybePath)) return null;
+  const start = Number(startRaw);
+  const end = Number(endRaw || startRaw);
+  if (!Number.isFinite(start) || start <= 0) return null;
+  if (!Number.isFinite(end) || end < start) return null;
+  return { path: maybePath, start_line: start, end_line: end };
+}
+
+function normalizeToolArguments(toolName, args, rawArguments) {
+  const rawText = typeof rawArguments === 'string' ? rawArguments.trim() : '';
+  const primitive =
+    args == null || Array.isArray(args) || typeof args !== 'object'
+      ? args
+      : null;
+  const source =
+    args && typeof args === 'object' && !Array.isArray(args)
+      ? { ...args }
+      : {};
+
+  if (primitive != null && typeof primitive !== 'object') {
+    source._raw = rawText || String(primitive);
+  } else if (!source._raw && rawText && source._invalid_json) {
+    source._raw = rawText;
+  }
+
+  const stringValue =
+    typeof primitive === 'string'
+      ? primitive.trim()
+      : String(source._raw || '').trim();
+
+  if (toolName === 'read') {
+    const value = String(source.path || source.file_path || source.file || stringValue || '').trim();
+    if (value) source.path = value;
+    if (source.offset != null && source.start_line == null) source.start_line = source.offset;
+    if (source.limit != null && source.end_line == null && Number(source.start_line) > 0) {
+      source.end_line = Number(source.start_line) + Number(source.limit) - 1;
+    }
+    const range = parseInlineRangePath(source.path);
+    if (range) {
+      source.path = range.path;
+      if (source.start_line == null) source.start_line = range.start_line;
+      if (source.end_line == null) source.end_line = range.end_line;
+    }
+    return source;
+  }
+
+  if (toolName === 'list') {
+    const value = String(source.path || source.dir || source.directory || stringValue || '.').trim();
+    return { ...source, path: value || '.' };
+  }
+
+  if (toolName === 'glob') {
+    const pattern = String(source.pattern || source.glob || source.query || stringValue || '').trim();
+    if (pattern) source.pattern = pattern;
+    if (!source.path && source.directory) source.path = source.directory;
+    return source;
+  }
+
+  if (toolName === 'grep') {
+    const pattern = String(source.pattern || source.query || source.symbol || source.q || stringValue || '').trim();
+    if (pattern) source.pattern = pattern;
+    if (!source.path && (source.directory || source.dir || source.cwd)) {
+      source.path = source.directory || source.dir || source.cwd;
+    }
+    return source;
+  }
+
+  if (toolName === 'write') {
+    const value = String(source.path || source.file_path || source.file || stringValue || '').trim();
+    if (value) source.path = value;
+    if (source.content == null && source.text != null) source.content = source.text;
+    if (source.content == null && source.new_content != null) source.content = source.new_content;
+    return source;
+  }
+
+  if (toolName === 'edit') {
+    const value = String(source.path || source.file || source.file_path || '').trim();
+    if (value && !source.path) source.path = value;
+    return source;
+  }
+
+  return source;
+}
+
+function emptyToolResultMarker(toolName) {
+  const name = String(toolName || 'tool').trim() || 'tool';
+  return `(${name} completed with no output)`;
+}
+
 function clipToolResult(result, maxChars = 12000) {
   const raw = typeof result === 'string' ? result : JSON.stringify(result);
   if (!maxChars || raw.length <= maxChars) return raw;
@@ -374,9 +469,12 @@ function formatToolDisplayName(name, args) {
 function formatToolResult(toolResult, toolName, args, toolFormatters, toolResultMaxChars) {
   if (toolFormatters && typeof toolFormatters[toolName] === 'function') {
     const formatted = toolFormatters[toolName](toolResult, args);
-    if (typeof formatted === 'string') return formatted;
+    if (typeof formatted === 'string') {
+      return formatted.trim() ? formatted : emptyToolResultMarker(toolName);
+    }
   }
-  return compactToolResult(toolResult, toolName, args, toolResultMaxChars);
+  const fallback = compactToolResult(toolResult, toolName, args, toolResultMaxChars);
+  return String(fallback || '').trim() ? fallback : emptyToolResultMarker(toolName);
 }
 
 // ─── Main agent loop ────────────────────────────────────────────────
@@ -469,8 +567,8 @@ export async function runAgentLoop({
     // ─── P1a: Partition into read-only (parallel) and write (serial) ──
 
     const callsWithMeta = toolCalls.map((call) => {
-      const args = safeJsonParse(call.arguments);
       const toolName = normalizeToolCallName(call.name);
+      const args = normalizeToolArguments(toolName, safeJsonParse(call.arguments), call.arguments);
       const displayName = formatToolDisplayName(toolName, args);
       const isReadOnly = READ_ONLY_TOOLS.has(toolName);
       return { call, args, toolName, displayName, isReadOnly };

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

@@ -2,6 +2,42 @@ import os from 'node:os';
 import fs from 'node:fs';
 import { getShellSystemPrompt } from './shell-profile.js';
 
+function getToolFewShotBlock() {
+  const cwd = process.cwd();
+  return `# Tool Examples
+
+Use these as style examples for tool calls:
+
+Current working directory: ${cwd}
+When a tool takes file_path, build it from the current working directory and prefer absolute paths.
+If the user mentions a project-relative path like src/app.ts, resolve it from ${cwd} instead of guessing parent directories.
+
+1. File discovery then read
+User: compare the auth flow
+Assistant: first locate the relevant files
+Tool: glob({"pattern":"src/**/*auth*.ts"})
+Tool: read({"file_path":"${cwd}/src/auth/service.ts"})
+
+2. Targeted search then exact text edit
+User: rename loginUser to signInUser
+Assistant: first find the exact occurrences
+Tool: grep({"pattern":"loginUser","path":"src"})
+Tool: edit({"file_path":"${cwd}/src/auth/service.ts","old_string":"loginUser","new_string":"signInUser"})
+
+3. Read a specific range
+User: inspect the reducer around line 120
+Assistant: read only the needed range
+Tool: read({"path":"${cwd}/src/store/reducer.ts:110-150"})
+
+4. Create a new file
+User: add a notes file
+Assistant: create the file directly
+Tool: write({"file":"${cwd}/notes.txt","text":"todo\\n"})
+
+Prefer these direct tool shapes over multi-step metadata reads or shell fallbacks.
+Prefer explicit absolute file_path values when the current working directory is known.`;
+}
+
 function getEnvBlock() {
   const cwd = process.cwd();
   let isGitRepo = false;
@@ -22,5 +58,7 @@ OS Version: ${os.version || os.release()}
 export function buildDefaultSystemPrompt(config = {}) {
   return `${getShellSystemPrompt(config?.shell?.default)}
 
+${getToolFewShotBlock()}
+
 ${getEnvBlock()}`;
 }

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

@@ -47,6 +47,16 @@ function normalizeToolCallArguments(argumentsText) {
   return '{}';
 }
 
+function normalizeIncomingToolCallArguments(argumentsValue) {
+  if (typeof argumentsValue === 'string') return argumentsValue;
+  if (argumentsValue == null) return '{}';
+  try {
+    return JSON.stringify(argumentsValue);
+  } catch {
+    return '{}';
+  }
+}
+
 function sanitizeGatewayMessages(messages) {
   const source = Array.isArray(messages) ? messages : [];
   return source
@@ -115,7 +125,18 @@ function buildPayload({ model, temperature, messages, tools, stream = false }) {
   return payload;
 }
 
-function buildFinalStreamResult(text, toolCallsByIndex, usage) {
+function hasTrailingToolContext(messages) {
+  const source = Array.isArray(messages) ? messages : [];
+  for (let index = source.length - 1; index >= 0; index -= 1) {
+    const message = source[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 buildFinalStreamResult(text, toolCallsByIndex, usage, messages) {
   const toolCalls = Array.from(toolCallsByIndex.entries())
     .sort((a, b) => a[0] - b[0])
     .map(([, tc], i) => ({
@@ -126,6 +147,13 @@ function buildFinalStreamResult(text, toolCallsByIndex, usage) {
     .filter((tc) => tc.name);
 
   if (!text && toolCalls.length === 0) {
+    if (hasTrailingToolContext(messages)) {
+      return {
+        text: '',
+        toolCalls: [],
+        usage
+      };
+    }
     throw new Error('Gateway stream returned empty assistant response');
   }
 
@@ -216,7 +244,7 @@ export async function createChatCompletion({
   const toolCalls = (message.tool_calls || []).map((tc) => ({
     id: tc.id,
     name: tc.function?.name,
-    arguments: tc.function?.arguments || '{}'
+    arguments: normalizeIncomingToolCallArguments(tc.function?.arguments)
   }));
 
   if (!text && toolCalls.length === 0) {
@@ -280,7 +308,9 @@ export async function createChatCompletionStream({
       const current = toolCallsByIndex.get(idx) || emptyToolCall(idx);
       if (td.id) current.id = td.id;
       if (td.function?.name) current.name = `${current.name}${td.function.name}`;
-      if (td.function?.arguments) current.arguments = `${current.arguments}${td.function.arguments}`;
+      if (td.function?.arguments !== undefined) {
+        current.arguments = `${current.arguments}${normalizeIncomingToolCallArguments(td.function.arguments)}`;
+      }
       toolCallsByIndex.set(idx, current);
       if (onToolCallDelta) {
         onToolCallDelta({
@@ -293,5 +323,5 @@ export async function createChatCompletionStream({
     }
   }
 
-  return buildFinalStreamResult(text, toolCallsByIndex, usage);
+  return buildFinalStreamResult(text, toolCallsByIndex, usage, messages);
 }

package/src/core/shell-profile.js

@@ -123,11 +123,11 @@ export function getShellSystemPrompt(value) {
 # Using your tools
 
 ALWAYS prefer dedicated tools over raw shell commands:
-- Use read to inspect files — NEVER use cat, head, or tail via run
+- 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 grep to search file contents — NEVER use grep or rg via run
 - Use glob to find files by pattern — NEVER use find via run
-- Use edit to modify existing files — this is the DEFAULT path for code changes
-- Use write only for creating new files or complete rewrites (set full_file_rewrite=true for existing code files)
+- 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 patch to apply unified diffs
 - Use run for one-shot shell commands: install, build, test, or other finite tasks
 - For long-running processes (dev servers, watchers), use start_service instead of run
@@ -140,6 +140,17 @@ For services: use start_service to launch, list_services/get_service_status/get_
 
 Some tools are loaded on demand. If a needed tool is not listed, call tool_search first to load it.
 
+Common tool call patterns:
+- Read a file: {path:"src/app.ts"} or {file_path:"src/app.ts", offset:20, limit:40}
+- Read a specific range inline: {path:"src/app.ts:20-60"}
+- Search text: {pattern:"loginUser", path:"src"} or {query:"loginUser", directory:"src"}
+- Find files: {pattern:"src/**/*.ts"} or {query:"src/**/*.ts"}
+- Edit exact text: {file_path:"src/app.ts", old_string:"foo", new_string:"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
+- 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
 
 - You are a terminal-first CLI coding agent, not a generic chat assistant