codemini-cli 0.3.4 → 0.3.5

package/package.json

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

package/souls/anime.md

@@ -1,14 +1,14 @@
-Respond with a light anime-inspired tone.
+Respond with a bright anime-sidekick tone: energetic, supportive, and lightly dramatic in a fun way.
 
 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.
+- Sound like a reliable teammate in a high-energy adventure, not a parody character.
+- Use short bursts of upbeat flavor in transitions or confirmations, then get back to the point.
+- Favor warm momentum: "Nice, we found it.", "Okay, next move.", "Close one, but fixable."
+- Let progress updates feel lively and encouraging, especially when debugging gets messy.
+- Keep any playful punctuation light and occasional.
 
 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.
+- Do not stuff responses with catchphrases, Japanese loanwords, memes, or roleplay.
+- Do not turn every sentence into a performance; the technical content stays central.
+- Stay concise and readable even when the tone is energetic.
 - Technical terms, code, file paths, and command output must remain precise and unchanged.

package/souls/caveman.md

@@ -1,13 +1,13 @@
-Respond with a simple caveman-inspired tone.
+Respond with a rugged caveman-inspired tone: blunt, simple, and action-first.
 
 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."
+- Keep sentences short, direct, and concrete.
+- Favor plain, physical metaphors when helpful: build, break, patch, carry, fix.
+- Let the tone feel sturdy and low-drama rather than goofy.
+- Use the caveman flavor as emphasis around decisions or outcomes, not every line.
 
 Boundaries:
+- Do not intentionally break grammar so much that the answer becomes harder to follow.
 - 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,14 +1,15 @@
-Respond with a bold, decisive CEO-style tone.
+Respond with a crisp operator-CEO tone: decisive, high-ownership, and focused on outcomes.
 
 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."
+- Sound like someone aligning a team around the next move, not giving a motivational speech.
+- Lead with direction: what matters, what we do now, and what risk needs watching.
+- Frame choices in terms of impact, tradeoffs, and execution speed.
+- Use confident but grounded phrasing such as "The right move is...", "Here's the tradeoff.", "Let's keep scope tight."
+- Let wins land cleanly and briefly: "Clean fix.", "Good tradeoff.", "Ready to ship."
 
 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.
+- Do not imitate any real executive or lean on empty business jargon.
+- Do not become abrasive, domineering, or dismissive of uncertainty.
+- Confidence must come from reasoning, not bluffing; if something is unknown, say so plainly.
 - Technical terms, code, file paths, and command output must remain precise and unchanged.
-- Stay concise — CEOs do not ramble.
+- Stay concise. Strong direction beats long speeches.

package/souls/default.md

@@ -3,7 +3,7 @@ Respond in a clear, calm, helpful tone.
 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.
+- Use simple, natural language with no forced personality or quirks.
 
 Boundaries:
 - Avoid roleplay, slang overload, or exaggerated personality.

package/souls/pirate.md

@@ -1,13 +1,13 @@
-Respond with a playful pirate-inspired tone, matey.
+Respond with a lightly nautical pirate tone: adventurous, playful, and easy to understand.
 
 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.
+- Add just a hint of seafaring flavor in openings, transitions, or short celebrations.
+- Keep the voice sturdy and practical, like a capable captain talking the crew through a repair.
+- Use maritime metaphors sparingly when they genuinely help clarity.
+- Let the personality show more in confirmations than in technical instructions.
 
 Boundaries:
+- Do not write in heavy dialect or make every sentence pirate-themed.
 - 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,13 +1,13 @@
-Respond with a witty, lively, and slightly cheeky tone.
+Respond with a witty, lively, lightly 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?"
+- Add personality through timing and phrasing, not constant jokes.
+- Keep humor warm and collaborative, like a teammate making the work feel lighter.
+- Use short, sharp transitions when they help the rhythm: "Small plot twist:", "Easy fix.", "That's the culprit."
+- Let wins feel satisfying without turning them into punchlines.
 
 Boundaries:
-- Keep the answer readable and practical first — humor is the seasoning, not the main dish.
+- Humor is seasoning, not the main dish.
 - Do not let jokes obscure instructions, warnings, or technical accuracy.
+- Avoid sarcasm that could feel dismissive, smug, or mean.
 - 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,7 +1,7 @@
 Respond in a polished, professional, and authoritative tone.
 
 Style guidelines:
-- Keep phrasing precise, confident, and concise — like a senior engineer briefing a team.
+- 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..."

package/src/core/agent-loop.js

@@ -692,8 +692,14 @@ export async function runAgentLoop({
     const assistantText = completion.text || '';
     lastAssistantText = assistantText || lastAssistantText;
 
-    const assistantMessage = { role: 'assistant', content: completion?.content ?? assistantText };
-    if (toolCalls.length > 0) {
+    const assistantMessage = completion?.assistantMessage
+      ? {
+          ...completion.assistantMessage,
+          role: 'assistant',
+          content: completion.assistantMessage.content ?? completion?.content ?? assistantText
+        }
+      : { role: 'assistant', content: completion?.content ?? assistantText };
+    if (!Array.isArray(assistantMessage.tool_calls) && toolCalls.length > 0) {
       assistantMessage.tool_calls = toolCalls.map((tc) => ({
         id: tc.id,
         type: 'function',

package/src/core/chat-runtime.js

@@ -41,6 +41,8 @@ function toOpenAIMessages(sessionMessages) {
     mapped.push({
       role: msg.role,
       content: msg.content,
+      ...(typeof msg.reasoning_content === 'string' && msg.reasoning_content ? { reasoning_content: msg.reasoning_content } : {}),
+      ...(Array.isArray(msg.reasoning_details) && msg.reasoning_details.length > 0 ? { reasoning_details: msg.reasoning_details } : {}),
       ...(msg.tool_calls ? { tool_calls: msg.tool_calls } : {})
     });
   }
@@ -1784,6 +1786,12 @@ async function askModel({
       if (activeAssistantIndex >= 0 && session.messages[activeAssistantIndex]) {
         const current = session.messages[activeAssistantIndex];
         current.content = event.assistantMessage?.content ?? event.text ?? current.content;
+        if (typeof event.assistantMessage?.reasoning_content === 'string' && event.assistantMessage.reasoning_content) {
+          current.reasoning_content = event.assistantMessage.reasoning_content;
+        }
+        if (Array.isArray(event.assistantMessage?.reasoning_details) && event.assistantMessage.reasoning_details.length > 0) {
+          current.reasoning_details = event.assistantMessage.reasoning_details;
+        }
         if (Array.isArray(event.assistantMessage?.tool_calls) && event.assistantMessage.tool_calls.length > 0) {
           current.tool_calls = event.assistantMessage.tool_calls;
         }

package/src/core/provider/anthropic.sdk-backup.js

@@ -0,0 +1,439 @@
+import Anthropic from '@anthropic-ai/sdk';
+
+function extractTextContent(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === 'string') return part;
+        if (part?.type === 'text') return part.text || '';
+        return '';
+      })
+      .join('');
+  }
+  return '';
+}
+
+function normalizeIncomingToolCallArguments(argumentsValue) {
+  if (typeof argumentsValue === 'string') return argumentsValue;
+  if (argumentsValue == null) return '{}';
+  try {
+    return JSON.stringify(argumentsValue);
+  } catch {
+    return '{}';
+  }
+}
+
+function tryParseJsonObject(raw) {
+  if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+    return raw;
+  }
+  if (typeof raw !== 'string') return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {}
+  return {};
+}
+
+function normalizeAssistantContentBlocks(message) {
+  if (Array.isArray(message?.content) && message.content.length > 0) {
+    return message.content.map((block) => ({ ...block }));
+  }
+
+  const contentBlocks = [];
+  const text = extractTextContent(message?.content);
+  if (text) {
+    contentBlocks.push({ type: 'text', text });
+  }
+
+  if (Array.isArray(message?.tool_calls)) {
+    for (const toolCall of message.tool_calls) {
+      const name = String(toolCall?.function?.name || toolCall?.name || '').trim();
+      if (!name) continue;
+      contentBlocks.push({
+        type: 'tool_use',
+        id: String(toolCall?.id || ''),
+        name,
+        input: tryParseJsonObject(toolCall?.function?.arguments ?? toolCall?.arguments)
+      });
+    }
+  }
+
+  return contentBlocks;
+}
+
+function normalizeMessages(messages) {
+  const source = Array.isArray(messages) ? messages : [];
+  const systemParts = [];
+  const out = [];
+
+  for (const message of source) {
+    if (!message || typeof message !== 'object') continue;
+    if (message.role === 'system') {
+      const text = extractTextContent(message.content);
+      if (text) systemParts.push(text);
+      continue;
+    }
+
+    if (message.role === 'tool') {
+      out.push({
+        role: 'user',
+        content: [
+          {
+            type: 'tool_result',
+            tool_use_id: String(message.tool_call_id || ''),
+            content: extractTextContent(message.content)
+          }
+        ]
+      });
+      continue;
+    }
+
+    if (message.role === 'assistant') {
+      out.push({
+        role: 'assistant',
+        content: normalizeAssistantContentBlocks(message)
+      });
+      continue;
+    }
+
+    out.push({
+      role: message.role,
+      content: [{ type: 'text', text: extractTextContent(message.content) }]
+    });
+  }
+
+  return {
+    system: systemParts.join('\n\n').trim() || undefined,
+    messages: out
+  };
+}
+
+function normalizeTools(tools) {
+  const source = Array.isArray(tools) ? tools : [];
+  return source
+    .map((tool) => {
+      const fn = tool?.function || {};
+      const name = String(fn.name || '').trim();
+      if (!name) return null;
+      return {
+        name,
+        ...(fn.description ? { description: String(fn.description) } : {}),
+        input_schema: fn.parameters && typeof fn.parameters === 'object' ? fn.parameters : { type: 'object' }
+      };
+    })
+    .filter(Boolean);
+}
+
+function buildPayload({ model, temperature, messages, tools, stream = false, maxTokens = 4096 }) {
+  const normalized = normalizeMessages(messages);
+  const payload = {
+    model,
+    max_tokens: maxTokens,
+    temperature,
+    messages: normalized.messages
+  };
+  if (normalized.system) payload.system = normalized.system;
+  if (stream) payload.stream = true;
+
+  const normalizedTools = normalizeTools(tools);
+  if (normalizedTools.length > 0) {
+    payload.tools = normalizedTools;
+    payload.tool_choice = { type: 'auto' };
+  }
+  return payload;
+}
+
+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 buildAssistantMessage(content) {
+  return {
+    role: 'assistant',
+    content
+  };
+}
+
+function extractAssistantResult(data, messages) {
+  const content = Array.isArray(data?.content) ? data.content.map((block) => ({ ...block })) : [];
+  const text = content
+    .filter((block) => block?.type === 'text')
+    .map((block) => block.text || '')
+    .join('');
+  const toolCalls = content
+    .filter((block) => block?.type === 'tool_use')
+    .map((block) => ({
+      id: String(block.id || ''),
+      name: String(block.name || ''),
+      arguments: normalizeIncomingToolCallArguments(block.input)
+    }))
+    .filter((toolCall) => toolCall.name);
+  const normalizedText = String(text || '').trim();
+
+  if (!normalizedText && toolCalls.length === 0) {
+    if (hasTrailingToolContext(messages)) {
+      return {
+        text: '',
+        toolCalls: [],
+        usage: data?.usage || null,
+        incomplete: true,
+        content
+      };
+    }
+    throw new Error('Anthropic gateway returned empty assistant response');
+  }
+
+  return {
+    text,
+    toolCalls,
+    usage: data?.usage || null,
+    content,
+    assistantMessage: buildAssistantMessage(content)
+  };
+}
+
+function mergeUsage(current, next) {
+  if (!next || typeof next !== 'object') return current;
+  return {
+    ...(current || {}),
+    ...next
+  };
+}
+
+function emptyToolCall(index) {
+  return {
+    index,
+    id: '',
+    name: '',
+    arguments: ''
+  };
+}
+
+function buildFinalStreamResult(text, toolCallsByIndex, usage, messages, contentBlocksByIndex) {
+  const toolCalls = Array.from(toolCallsByIndex.entries())
+    .sort((a, b) => a[0] - b[0])
+    .map(([, tc], i) => ({
+      id: tc.id || `tc-${i + 1}`,
+      name: tc.name,
+      arguments: tc.arguments || '{}'
+    }))
+    .filter((tc) => tc.name);
+  const normalizedText = String(text || '').trim();
+  const content = Array.from(contentBlocksByIndex.entries())
+    .sort((a, b) => a[0] - b[0])
+    .map(([, block]) => {
+      if (block.type === 'tool_use') {
+        return {
+          type: 'tool_use',
+          id: block.id,
+          name: block.name,
+          input: tryParseJsonObject(block.arguments)
+        };
+      }
+      if (block.type === 'thinking') {
+        return {
+          type: 'thinking',
+          thinking: block.thinking || '',
+          ...(block.signature ? { signature: block.signature } : {})
+        };
+      }
+      return {
+        type: 'text',
+        text: block.text || ''
+      };
+    })
+    .filter((block) => {
+      if (block.type === 'tool_use') return Boolean(block.name);
+      if (block.type === 'thinking') return Boolean(block.thinking);
+      return Boolean(block.text);
+    });
+
+  if (!normalizedText && toolCalls.length === 0) {
+    if (hasTrailingToolContext(messages)) {
+      return {
+        text: '',
+        toolCalls: [],
+        usage,
+        incomplete: true,
+        content: []
+      };
+    }
+    throw new Error('Anthropic gateway stream returned empty assistant response');
+  }
+
+  return {
+    text,
+    toolCalls,
+    usage,
+    incomplete: false,
+    content,
+    assistantMessage: buildAssistantMessage(content)
+  };
+}
+
+function createClient({ baseUrl, apiKey, timeoutMs = 90000, maxRetries = 2 }) {
+  return new Anthropic({
+    apiKey,
+    baseURL: String(baseUrl || '').replace(/\/$/, ''),
+    timeout: timeoutMs,
+    maxRetries
+  });
+}
+
+function inferEventType(event) {
+  const explicit = String(event?.type || event?.event || '').trim();
+  if (explicit) return explicit;
+  if (event?.content_block && typeof event?.index === 'number') return 'content_block_start';
+  if (event?.delta && typeof event?.index === 'number') return 'content_block_delta';
+  if (event?.message) return 'message_start';
+  if (event?.usage) return 'message_delta';
+  if (event && typeof event === 'object' && Object.keys(event).length === 0) return 'message_stop';
+  return '';
+}
+
+export async function createChatCompletion({
+  baseUrl,
+  apiKey,
+  model,
+  messages,
+  temperature = 0.2,
+  tools,
+  timeoutMs = 90000,
+  maxTokens = 4096,
+  maxRetries = 2
+}) {
+  const client = createClient({ baseUrl, apiKey, timeoutMs, maxRetries });
+  const response = await client.messages.create(buildPayload({ model, temperature, messages, tools, maxTokens }));
+  return extractAssistantResult(response, messages);
+}
+
+export async function createChatCompletionStream({
+  baseUrl,
+  apiKey,
+  model,
+  messages,
+  temperature = 0.2,
+  tools,
+  onTextDelta,
+  onToolCallDelta,
+  timeoutMs = 90000,
+  maxTokens = 4096,
+  maxRetries = 2
+}) {
+  const client = createClient({ baseUrl, apiKey, timeoutMs, maxRetries });
+  const stream = await client.messages.create(buildPayload({ model, temperature, messages, tools, stream: true, maxTokens }));
+
+  let text = '';
+  let usage = null;
+  const toolCallsByIndex = new Map();
+  const contentBlocksByIndex = new Map();
+
+  for await (const event of stream) {
+    const eventType = inferEventType(event);
+    usage = mergeUsage(usage, event?.usage);
+    usage = mergeUsage(usage, event?.message?.usage);
+
+    if (eventType === 'content_block_start') {
+      const index = Number(event?.index ?? 0);
+      const contentBlock = event?.content_block || {};
+      if (contentBlock.type === 'tool_use') {
+        const current = toolCallsByIndex.get(index) || emptyToolCall(index);
+        current.id = String(contentBlock.id || current.id || '');
+        current.name = String(contentBlock.name || current.name || '');
+        const initialInput = contentBlock.input && Object.keys(contentBlock.input).length > 0
+          ? normalizeIncomingToolCallArguments(contentBlock.input)
+          : '';
+        current.arguments = current.arguments || initialInput;
+        toolCallsByIndex.set(index, current);
+        contentBlocksByIndex.set(index, {
+          type: 'tool_use',
+          id: current.id,
+          name: current.name,
+          arguments: current.arguments
+        });
+      } else if (contentBlock.type === 'thinking') {
+        contentBlocksByIndex.set(index, {
+          type: 'thinking',
+          thinking: String(contentBlock.thinking || ''),
+          signature: String(contentBlock.signature || '')
+        });
+      } else {
+        contentBlocksByIndex.set(index, {
+          type: 'text',
+          text: String(contentBlock.text || '')
+        });
+      }
+      continue;
+    }
+
+    if (eventType === 'content_block_delta') {
+      const index = Number(event?.index ?? 0);
+      const delta = event?.delta || {};
+      if (delta.type === 'text_delta' && delta.text) {
+        text += delta.text;
+        const current = contentBlocksByIndex.get(index) || { type: 'text', text: '' };
+        current.text = `${current.text || ''}${delta.text}`;
+        contentBlocksByIndex.set(index, current);
+        if (onTextDelta) onTextDelta(delta.text);
+        continue;
+      }
+
+      if (delta.type === 'thinking_delta' && delta.thinking) {
+        const current = contentBlocksByIndex.get(index) || { type: 'thinking', thinking: '', signature: '' };
+        current.thinking = `${current.thinking || ''}${delta.thinking}`;
+        contentBlocksByIndex.set(index, current);
+        continue;
+      }
+
+      if (delta.type === 'signature_delta') {
+        const current = contentBlocksByIndex.get(index) || { type: 'thinking', thinking: '', signature: '' };
+        current.signature = `${current.signature || ''}${String(delta.signature || '')}`;
+        contentBlocksByIndex.set(index, current);
+        continue;
+      }
+
+      if (delta.type === 'input_json_delta') {
+        const current = toolCallsByIndex.get(index) || emptyToolCall(index);
+        current.arguments = `${current.arguments || ''}${String(delta.partial_json || '')}`;
+        toolCallsByIndex.set(index, current);
+        contentBlocksByIndex.set(index, {
+          type: 'tool_use',
+          id: current.id,
+          name: current.name,
+          arguments: current.arguments
+        });
+        if (onToolCallDelta) {
+          onToolCallDelta({
+            index,
+            id: current.id || `tc-${index + 1}`,
+            name: current.name,
+            arguments: current.arguments || '{}'
+          });
+        }
+      }
+      continue;
+    }
+
+    if (eventType === 'message_delta') {
+      usage = mergeUsage(usage, event?.delta?.usage);
+      continue;
+    }
+
+    if (eventType === 'message_stop') {
+      break;
+    }
+  }
+
+  return buildFinalStreamResult(text, toolCallsByIndex, usage, messages, contentBlocksByIndex);
+}