codemini-cli 0.1.13 → 0.1.15

package/src/tui/chat-app.js

@@ -316,6 +316,11 @@ function getActivityDisplayParts(activity) {
     read_file: 'Read',
     write_file: 'Write',
     run_command: 'Command',
+    start_service: 'Service',
+    list_services: 'Service',
+    get_service_status: 'Service',
+    get_service_logs: 'Service',
+    stop_service: 'Service',
     list_files: 'Glob',
     create_task: 'Task',
     update_task: 'Task'
@@ -357,6 +362,13 @@ function describeToolActivity(name, copy, { done = false, blocked = false } = {}
         ? `${copy.toolActivity.doneCommand}: ${safeTarget || 'run_command'}`
         : `${copy.toolActivity.doingCommand}: ${safeTarget || 'run_command'}`;
   }
+  if (base === 'start_service' || base === 'list_services' || base === 'get_service_status' || base === 'get_service_logs' || base === 'stop_service') {
+    return blocked
+      ? `${copy.toolActivity.blocked}: ${safeTarget || base}`
+      : done
+        ? `${copy.toolActivity.doneGeneric}: ${safeTarget || base}`
+        : `${copy.toolActivity.doingGeneric}: ${safeTarget || base}`;
+  }
   if (base === 'create_task') {
     return blocked ? `${copy.toolActivity.blocked}: create_task` : done ? copy.toolActivity.doneCreateTask : copy.toolActivity.doingCreateTask;
   }
@@ -472,9 +484,13 @@ function PlanStrip({ planState, copy }) {
           ...planState.steps.slice(-4).map((step, idx) =>
             h(
               Box,
-              { key: `plan-step-${idx}` },
+              { key: `plan-step-${idx}`, marginTop: idx === 0 ? 0 : 1 },
               h(Text, { color: step.status === 'active' ? 'cyanBright' : step.status === 'failed' ? 'redBright' : 'gray' }, `${step.status === 'active' ? '>' : step.status === 'failed' ? 'x' : '·'} `),
-              h(Text, { color: step.status === 'active' ? 'white' : step.status === 'failed' ? 'redBright' : 'gray' }, `${step.index}/${step.total} ${step.role}: ${step.title}`)
+              h(Text, { color: step.status === 'active' ? 'yellowBright' : step.status === 'failed' ? 'redBright' : 'gray' }, `${step.index}/${step.total}`),
+              h(Text, { color: 'gray' }, '  '),
+              h(Text, { color: step.status === 'active' ? 'magentaBright' : step.status === 'failed' ? 'redBright' : 'gray' }, String(step.role || 'agent').toUpperCase()),
+              h(Text, { color: 'gray' }, '  '),
+              h(Text, { color: step.status === 'active' ? 'white' : step.status === 'failed' ? 'redBright' : 'gray' }, step.title)
             )
           )
         )
@@ -583,6 +599,39 @@ export function parseAutoPlanSummaryMessage(text) {
   return parsed;
 }
 
+export function parsePlanProgressLine(text) {
+  const raw = String(text || '').trim();
+  const match = raw.match(/^\[plan\]\s+Step\s+(\d+)\/(\d+)\s+->\s+([^:]+):\s+(.+)$/i);
+  if (!match) return null;
+  return {
+    current: Number(match[1]),
+    total: Number(match[2]),
+    role: String(match[3] || '').trim(),
+    title: String(match[4] || '').trim()
+  };
+}
+
+export function injectPlanStateMessage(messages, planState, activeUserMessageId, activeAssistantId) {
+  const source = Array.isArray(messages) ? messages : [];
+  if (!planState || !planState.total) return source;
+  const synthetic = {
+    id: `plan-state-${planState.current}-${planState.total}-${planState.role || 'agent'}`,
+    label: 'system',
+    planStrip: true,
+    planState
+  };
+  const withNoPlanStrip = source.filter((message) => !message?.planStrip);
+  const userIdx = withNoPlanStrip.findIndex((message) => message.id === activeUserMessageId);
+  if (userIdx !== -1) {
+    return [...withNoPlanStrip.slice(0, userIdx + 1), synthetic, ...withNoPlanStrip.slice(userIdx + 1)];
+  }
+  const assistantIdx = withNoPlanStrip.findIndex((message) => message.id === activeAssistantId);
+  if (assistantIdx !== -1) {
+    return [...withNoPlanStrip.slice(0, assistantIdx), synthetic, ...withNoPlanStrip.slice(assistantIdx)];
+  }
+  return [...withNoPlanStrip, synthetic];
+}
+
 function PlanSummaryBubble({ msg, copy }) {
   const theme = roleStyle(msg.label);
   const summary = msg.planSummary || parseAutoPlanSummaryMessage(msg.text);
@@ -760,6 +809,114 @@ function pushWrappedRow(rows, baseRow, contentWidth) {
   });
 }
 
+function isActivityRow(row) {
+  return row?.kind === 'activity' || row?.kind === 'activity-summary';
+}
+
+function isBlankTextRow(row) {
+  return row?.kind === 'text' && String(row?.text || '').trim() === '';
+}
+
+export function normalizeActivitySpacingRows(inputRows) {
+  const rows = Array.isArray(inputRows) ? inputRows : [];
+  const normalized = [];
+
+  for (let index = 0; index < rows.length; index += 1) {
+    const row = rows[index];
+    const prev = normalized.at(-1);
+    const next = rows[index + 1];
+
+    if (isBlankTextRow(row)) {
+      let lookahead = index + 1;
+      while (lookahead < rows.length && isBlankTextRow(rows[lookahead])) {
+        lookahead += 1;
+      }
+      if (isActivityRow(rows[lookahead])) {
+        continue;
+      }
+    }
+
+    if (isBlankTextRow(row) && isActivityRow(next)) {
+      continue;
+    }
+
+    normalized.push(row);
+
+    if (isActivityRow(row) && !isActivityRow(next) && next) {
+      const last = normalized.at(-1);
+      if (!isBlankTextRow(last) && !(next.kind === 'status')) {
+        normalized.push({
+          kind: 'text',
+          text: ' ',
+          color: 'white'
+        });
+      }
+    }
+
+    if (isBlankTextRow(row) && isBlankTextRow(prev)) {
+      normalized.pop();
+    }
+  }
+
+  return normalized;
+}
+
+function isReadActivityName(name) {
+  const parsed = parseToolDisplayName(name);
+  return parsed.base === 'read_file' || parsed.base === 'Read';
+}
+
+function isIgnorableSegmentAfterRead(item, activityType, activityName) {
+  if (!item) return true;
+  if (item.type === 'text') {
+    return String(item.text || '').trim() === '';
+  }
+  return (item.type || 'tool') === activityType && item.name === activityName;
+}
+
+export function findActivityUpdateIndex(items, toolEvent) {
+  const source = Array.isArray(items) ? items : [];
+  const activityType = toolEvent?.type || 'tool';
+  const byId = toolEvent?.id
+    ? source.findIndex((item) => item.type === activityType && item.id && item.id === toolEvent.id)
+    : -1;
+  if (byId !== -1) return byId;
+
+  const byNameRunning = source.findIndex(
+    (item) => (item.type || 'tool') === activityType && item.name === toolEvent?.name && item.status !== 'done'
+  );
+  if (byNameRunning !== -1) return byNameRunning;
+
+  if (isReadActivityName(toolEvent?.name)) {
+    for (let index = source.length - 1; index >= 0; index -= 1) {
+      const item = source[index];
+      if ((item?.type || 'tool') !== activityType || item?.name !== toolEvent?.name) continue;
+      const trailing = source.slice(index + 1);
+      if (trailing.every((entry) => isIgnorableSegmentAfterRead(entry, activityType, toolEvent?.name))) {
+        return index;
+      }
+    }
+  }
+
+  return -1;
+}
+
+export function mergeActivitySummary(previousSummary, nextSummary, activityName) {
+  const prev = String(previousSummary || '').trim();
+  const next = String(nextSummary || '').trim();
+  if (!next) return prev;
+  if (!prev) return next;
+  if (!isReadActivityName(activityName) || prev === next) return next;
+
+  const lines = [];
+  for (const line of `${prev}\n${next}`.split('\n')) {
+    const trimmed = String(line || '').trim();
+    if (!trimmed) continue;
+    if (!lines.includes(trimmed)) lines.push(trimmed);
+  }
+  return lines.join('\n');
+}
+
 function buildMessageRows(msg, showToolDetails, contentWidth = 72) {
   const rows = [];
   const pushTextRows = (text) => {
@@ -767,6 +924,17 @@ function buildMessageRows(msg, showToolDetails, contentWidth = 72) {
     let codeFence = false;
     for (const line of lines) {
       const trimmed = line.trim();
+      const planProgress = parsePlanProgressLine(trimmed);
+      if (planProgress) {
+        rows.push({
+          kind: 'plan-progress',
+          current: planProgress.current,
+          total: planProgress.total,
+          role: planProgress.role,
+          title: trimText(planProgress.title, Math.max(12, contentWidth - 18))
+        });
+        continue;
+      }
       if (trimmed.startsWith('```')) {
         codeFence = !codeFence;
         continue;
@@ -843,7 +1011,7 @@ function buildMessageRows(msg, showToolDetails, contentWidth = 72) {
     );
   }
 
-  return rows;
+  return normalizeActivitySpacingRows(rows);
 }
 
 
@@ -945,6 +1113,13 @@ export function moveSuggestionSelection(currentIndex, itemCount, direction, page
 }
 
 function MessageBubble({ msg, loaderTick, showToolDetails, rowWindow = null, contentWidth = 72, copy }) {
+  if (msg?.planStrip) {
+    return h(
+      Box,
+      { marginBottom: 1 },
+      h(PlanStrip, { planState: msg.planState, copy })
+    );
+  }
   if (msg?.planSummary || parseAutoPlanSummaryMessage(msg?.text)) {
     return h(PlanSummaryBubble, { msg, copy });
   }
@@ -991,6 +1166,18 @@ function MessageBubble({ msg, loaderTick, showToolDetails, rowWindow = null, con
         h(Text, { color: 'gray' }, `└ ${row.text}`)
       );
     }
+    if (row.kind === 'plan-progress') {
+      return h(
+        Box,
+        { key: `row-plan-progress-${msg.id}-${idx}`, marginTop: 1, marginBottom: 1 },
+        h(Text, { color: 'cyanBright' }, '[plan] '),
+        h(Text, { color: 'yellowBright' }, `Step ${row.current}/${row.total}`),
+        h(Text, { color: 'gray' }, '  ->  '),
+        h(Text, { color: 'magentaBright' }, String(row.role || 'agent').toUpperCase()),
+        h(Text, { color: 'gray' }, ': '),
+        h(Text, { color: 'white' }, row.title)
+      );
+    }
     if (row.kind === 'status') {
       const dots = '.'.repeat((loaderTick % 3) + 1);
       const phase = msg.phase;
@@ -1456,13 +1643,7 @@ export function ChatApp({ runtime, sessionId, model, language = 'zh', shellName
         if (m.id !== targetId) return m;
         const toolCalls = Array.isArray(m.toolCalls) ? [...m.toolCalls] : [];
         const activityType = toolEvent.type || 'tool';
-        const byId = toolEvent.id
-          ? toolCalls.findIndex((t) => t.type === activityType && t.id && t.id === toolEvent.id)
-          : -1;
-        const byNameRunning = toolCalls.findIndex(
-          (t) => (t.type || 'tool') === activityType && t.name === toolEvent.name && t.status !== 'done'
-        );
-        const idx = byId !== -1 ? byId : byNameRunning;
+        const idx = findActivityUpdateIndex(toolCalls, toolEvent);
 
         if (idx === -1) {
           toolCalls.push({
@@ -1480,17 +1661,13 @@ export function ChatApp({ runtime, sessionId, model, language = 'zh', shellName
             id: toolEvent.id || toolCalls[idx].id,
             status: toolEvent.status,
             ...(toolEvent.durationMs !== undefined ? { durationMs: toolEvent.durationMs } : {}),
-            ...(toolEvent.summary ? { summary: toolEvent.summary } : {})
+            ...(toolEvent.summary
+              ? { summary: mergeActivitySummary(toolCalls[idx].summary, toolEvent.summary, toolEvent.name) }
+              : {})
           };
         }
         const segments = Array.isArray(m.segments) ? [...m.segments] : [];
-        const bySegmentId = toolEvent.id
-          ? segments.findIndex((segment) => segment.type === activityType && segment.id === toolEvent.id)
-          : -1;
-        const bySegmentName = segments.findIndex(
-          (segment) => segment.type === activityType && segment.name === toolEvent.name && segment.status !== 'done'
-        );
-        const segmentIdx = bySegmentId !== -1 ? bySegmentId : bySegmentName;
+        const segmentIdx = findActivityUpdateIndex(segments, toolEvent);
         const patch = {
           type: activityType,
           id: toolEvent.id || '',
@@ -1504,7 +1681,10 @@ export function ChatApp({ runtime, sessionId, model, language = 'zh', shellName
         } else {
           segments[segmentIdx] = {
             ...segments[segmentIdx],
-            ...patch
+            ...patch,
+            ...(toolEvent.summary
+              ? { summary: mergeActivitySummary(segments[segmentIdx].summary, toolEvent.summary, toolEvent.name) }
+              : {})
           };
         }
         return { ...m, toolCalls, segments };
@@ -2192,16 +2372,21 @@ export function ChatApp({ runtime, sessionId, model, language = 'zh', shellName
   const hasConversationStarted = messages.some((m) =>
     ['you', 'coder', 'pending', 'error'].includes(m.label)
   );
-  const visibleMessages = hasConversationStarted
+  const baseVisibleMessages = hasConversationStarted
     ? messages.filter((m) => !(m.label === 'system' && m.text === startupHint))
     : messages;
+  const visibleMessages = injectPlanStateMessage(
+    baseVisibleMessages,
+    planState,
+    activeUserMessageIdRef.current,
+    activeAssistantIdRef.current
+  );
 
   return h(
     Box,
     { flexDirection: 'column' },
     h(Header, { sessionId: displaySessionId, model: displayModel, shellName }),
     h(RuntimeStrip, { busy, runtimeStatus, loaderTick, copy }),
-    h(PlanStrip, { planState, copy }),
     h(MessageList, {
       messages: visibleMessages,
       loaderTick,

package/skills/executing-plan-lite/SKILL.md

@@ -1,41 +0,0 @@
----
-name: executing-plan-lite
-description: Lightweight plan execution skill for 30B-class models. Execute the plan in small verified steps with narrow context and frequent checks.
-version: 0.1.0
----
-
-Use this skill when a direction is chosen and the next job is to carry out implementation reliably.
-
-Rules:
-
-1. Execute the plan in small verified steps.
-Take one bounded step at a time. Avoid mixing planning, implementation, and verification into one big jump.
-
-2. Keep the active context narrow.
-Work from the smallest relevant file set and recent evidence. If needed, use sub-agents for independent subtasks.
-
-3. Search before editing.
-Use `rg` to locate code, inspect the smallest useful context, then edit.
-
-4. Verify after each meaningful change.
-Run the most relevant test or command before claiming success.
-
-5. Report progress briefly.
-Summarize what changed, what was verified, and what remains.
-
-Suggested flow:
-- identify the next step
-- search and inspect
-- edit
-- verify
-- either continue or stop at a clear checkpoint
-
-Use sub-agents when:
-- the task can be split cleanly
-- the write scope is disjoint
-- the result can be reviewed independently
-
-Avoid:
-- broad refactors without a reason
-- carrying full history into each step
-- declaring completion without verification