zerg-ztc 0.1.4 → 0.1.6

package/src/App.tsx

@@ -1,12 +1,13 @@
 import React, { useState, useCallback, useMemo, useRef } from 'react';
-import { Box, useApp, useInput } from 'ink';
-import { Header, MessageList, InputArea, StatusBar, FullScreen, useScreenSize } from './components/index.js';
+import { Box, useApp, useInput, Static } from 'ink';
+import { Header, MessageList, SingleMessage, InputArea, StatusBar, FullScreen, ActivityLine, useScreenSize } from './components/index.js';
 import { buildAppView } from './ui/views/app.js';
 import { useMirror } from './web/mirror_hook.js';
 import { Agent } from './agent/index.js';
 import { commands, type CommandContext } from './agent/commands/index.js';
 import { Message, AgentState, InputMode } from './types.js';
 import { InputState } from './ui/core/input_state.js';
+import { estimateInputLines } from './ui/views/input_area.js';
 import { configStore } from './config.js';
 import { createInputBus } from './ui/core/input.js';
 import { loadEmulationProfiles, getEmulationProfile } from './emulation/catalog.js';
@@ -20,6 +21,10 @@ import { autoActivateSkills, buildSkillPrompt } from './skills/index.js';
 import { getSkillRegistry } from './skills/registry.js';
 import { Skill } from './skills/types.js';
 import { createAgentFromConfig } from './agent/factory.js';
+import { checkForUpdate } from './utils/update.js';
+import { getVersion } from './utils/version.js';
+import { DEFAULT_SPINNER_VERBS } from './utils/spinner_verbs.js';
+import { SPINNER_FRAMES } from './utils/spinner_frames.js';
 
 // --- Utilities ---
 
@@ -78,6 +83,7 @@ export const App: React.FC = () => {
   const queueRef = useRef<string[]>([]);
   const activeRunIdRef = useRef<string | null>(null);
   const runCounterRef = useRef(0);
+  const lastRunDurationRef = useRef<number | null>(null);
 
   React.useEffect(() => {
     let active = true;
@@ -106,6 +112,8 @@ export const App: React.FC = () => {
   const [retryAvailable, setRetryAvailable] = useState(false);
   const [toast, setToast] = useState<string | null>(null);
   const toastTimerRef = useRef<NodeJS.Timeout | null>(null);
+  const [spinnerLabel, setSpinnerLabel] = useState<string | null>(null);
+  const [spinnerFrame, setSpinnerFrame] = useState<string | null>(null);
   const streamingMessageId = React.useRef<string | null>(null);
   const streamedResponse = React.useRef(false);
   const toolStartTimes = React.useRef<Map<string, number[]>>(new Map());
@@ -117,6 +125,8 @@ export const App: React.FC = () => {
   );
   const contextLength = agentState.contextTokens ?? fallbackContextLength;
   const contextEstimated = agentState.contextTokens ? agentState.tokensEstimated : true;
+  const spinnerVerbs = configStore.get().spinnerVerbs || DEFAULT_SPINNER_VERBS;
+  const spinnerVerbsKey = spinnerVerbs.join('|');
 
   React.useEffect(() => {
     renderCount.current += 1;
@@ -126,15 +136,69 @@ export const App: React.FC = () => {
     messagesRef.current = messages;
   }, [messages]);
   const [debug, setDebug] = useState(false);
+  const scrollback = process.env.ZTC_SCROLLBACK === '1' || process.env.ZTC_ALT_SCREEN !== '1';
 
-  const inputHeight = 5; // 1 input line + 4 suggestion lines
-  const headerHeight = 1;
+  React.useEffect(() => {
+    if (agentState.status !== 'thinking' && agentState.status !== 'streaming') {
+      setSpinnerLabel(null);
+      setSpinnerFrame(null);
+      return;
+    }
+    if (spinnerVerbs.length === 0) {
+      setSpinnerLabel(null);
+      setSpinnerFrame(null);
+      return;
+    }
+    const verb = spinnerVerbs[Math.floor(Math.random() * spinnerVerbs.length)];
+    setSpinnerLabel(verb);
+  }, [agentState.status, spinnerVerbsKey]);
+
+  React.useEffect(() => {
+    if (agentState.status !== 'thinking' && agentState.status !== 'streaming') {
+      setSpinnerFrame(null);
+      return;
+    }
+    // Animation is now safe in scrollback mode because we use Ink's Static component
+    // for completed messages - only the live section below Static re-renders
+    let index = 0;
+    setSpinnerFrame(SPINNER_FRAMES[index]);
+    const interval = setInterval(() => {
+      index = (index + 1) % SPINNER_FRAMES.length;
+      setSpinnerFrame(SPINNER_FRAMES[index]);
+    }, 120);
+    return () => {
+      clearInterval(interval);
+    };
+  }, [agentState.status]);
+
+  const headerHeight = scrollback ? 0 : 4; // border (2) + content (1) + margin (1)
   const statusHeight = 1;
+  const suggestionLines = 4;
+
+  const estimateBadgePreviewLines = useCallback((state: InputState): number => {
+    const segment = state.segments[state.cursor.index];
+    if (!segment || segment.type === 'text') return 0;
+    if (segment.type === 'paste') {
+      const lines = segment.text.split('\n');
+      return Math.min(3, lines.length) + (lines.length > 3 ? 1 : 0);
+    }
+    if (segment.type === 'image') {
+      return 16;
+    }
+    return 1;
+  }, []);
+
+  const inputHeight = useMemo(() => {
+    const inputLineCount = estimateInputLines(inputSnapshot.segments, columns);
+    const previewLines = estimateBadgePreviewLines(inputSnapshot);
+    const maxInputLines = Math.max(1, rows - (headerHeight + statusHeight + suggestionLines + 5));
+    return Math.min(Math.max(1, inputLineCount + previewLines), maxInputLines) + suggestionLines;
+  }, [columns, estimateBadgePreviewLines, inputSnapshot, rows]);
 
   // Calculate content height (total - header - input - status)
   const contentHeight = useMemo(
-    () => Math.max(rows - (headerHeight + inputHeight + statusHeight), 5),
-    [rows]
+    () => scrollback ? undefined : Math.max(rows - (headerHeight + inputHeight + statusHeight), 5),
+    [rows, scrollback, inputHeight]
   );
 
   // Reload agent when config changes
@@ -180,6 +244,21 @@ export const App: React.FC = () => {
     }]);
   }, []);
 
+  React.useEffect(() => {
+    if (process.env.ZTC_DISABLE_UPDATE === '1') return;
+    if (process.env.ZTC_WEB_MIRROR === '1') return;
+    let active = true;
+    const current = getVersion();
+    checkForUpdate(current).then(info => {
+      if (!active || !info.hasUpdate) return;
+      addMessage({
+        role: 'system',
+        content: `Update available: v${info.latest} (current v${info.current}). Run /update to install.`
+      });
+    }).catch(() => {});
+    return () => { active = false; };
+  }, [addMessage]);
+
   const clearMessages = useCallback(() => {
     setMessages([]);
   }, []);
@@ -191,10 +270,14 @@ export const App: React.FC = () => {
     setCwd: async (path: string) => {
       const next = await resolveWorkingDir(shellCwdRef.current, path);
       shellCwdRef.current = next;
+      // Also update agent's working directory so tools use it
+      if (agent) {
+        agent.setCwd(next);
+      }
       return next;
     },
     run: async (command: string) => runShellCommand(command, shellCwdRef.current)
-  }), []);
+  }), [agent]);
 
   const isRetryableError = useCallback((message: string) => {
     const lower = message.toLowerCase();
@@ -261,6 +344,7 @@ export const App: React.FC = () => {
     const runId = `${Date.now()}_${runCounterRef.current++}`;
     activeRunIdRef.current = runId;
     const isActive = () => activeRunIdRef.current === runId;
+    const runStartedAt = Date.now();
     setAgentState({ status: 'thinking', startedAt: new Date() });
     void runWithRetry(last.messages, last.agent, true, isActive).catch((err) => {
       const message = (err as Error).message || 'Agent error';
@@ -331,7 +415,13 @@ export const App: React.FC = () => {
     if (text.startsWith('!')) {
       const commandText = text.slice(1).trim();
       if (commandText) {
-        handleCommand('shell', [commandText]);
+        // Intercept 'cd' commands to use the proper /cd handler that persists
+        if (commandText === 'cd' || commandText.startsWith('cd ')) {
+          const path = commandText.slice(2).trim();
+          handleCommand('cd', path ? [path] : []);
+        } else {
+          handleCommand('shell', [commandText]);
+        }
       }
       return;
     }
@@ -417,6 +507,7 @@ export const App: React.FC = () => {
     const runId = `${Date.now()}_${runCounterRef.current++}`;
     activeRunIdRef.current = runId;
     const isActive = () => activeRunIdRef.current === runId;
+    const runStartedAt = Date.now();
     setAgentState({ status: 'thinking', startedAt: new Date() });
     streamingMessageId.current = null;
     streamedResponse.current = false;
@@ -466,10 +557,18 @@ export const App: React.FC = () => {
           break;
         case 'stream_end':
           if (streamingMessageId.current) {
-            setMessages(prev => prev.map(msg => {
-              if (msg.id !== streamingMessageId.current) return msg;
-              return { ...msg, isStreaming: false };
-            }));
+            setMessages(prev => {
+              // Remove the streaming message if it ended up empty (tool-only response)
+              const streamingMsg = prev.find(m => m.id === streamingMessageId.current);
+              if (streamingMsg && (!streamingMsg.content || streamingMsg.content.trim() === '')) {
+                return prev.filter(m => m.id !== streamingMessageId.current);
+              }
+              // Otherwise mark it as no longer streaming
+              return prev.map(msg => {
+                if (msg.id !== streamingMessageId.current) return msg;
+                return { ...msg, isStreaming: false };
+              });
+            });
           }
           streamingMessageId.current = null;
           break;
@@ -480,7 +579,7 @@ export const App: React.FC = () => {
           toolStartTimes.current.set(key, bucket);
           const duration = started ? Date.now() - started : undefined;
           const emulationId = configStore.getEmulationId();
-          if (getTraceStyle(emulationId) === 'claude_code') {
+          if (getTraceStyle(emulationId) === 'claude_code' || getTraceStyle(emulationId) === 'codex') {
             const output = buildToolOutputMessage(event.tool, event.result, duration, emulationId);
             addMessage({
               role: 'tool',
@@ -553,6 +652,14 @@ export const App: React.FC = () => {
         streamedResponse.current = false;
         streamingMessageId.current = null;
         activeRunIdRef.current = null;
+        lastRunDurationRef.current = Date.now() - runStartedAt;
+        if (getTraceStyle(configStore.getEmulationId()) === 'codex') {
+          const seconds = Math.max(0, Math.round((lastRunDurationRef.current || 0) / 1000));
+          addMessage({
+            role: 'tool',
+            content: `✻ Worked for ${seconds}s`
+          });
+        }
         cleanup();
         if (inputMode === 'queue' && queueRef.current.length > 0) {
           const next = queueRef.current.shift();
@@ -577,6 +684,7 @@ export const App: React.FC = () => {
       rows,
       commands,
       hasApiKey: configStore.hasApiKey(),
+      version: getVersion(),
       contextLength,
       contextEstimated,
       provider,
@@ -584,10 +692,12 @@ export const App: React.FC = () => {
       emulationId,
       inputMode,
       toast,
+      spinnerLabel,
+      spinnerFrame,
       debug,
       expandToolOutputs
     });
-  }, [mirrorEnabled, messages, agentState, inputSnapshot, sessionId, rows, contextLength, contextEstimated, provider, model, emulationId, inputMode, toast, debug, expandToolOutputs]);
+  }, [mirrorEnabled, messages, agentState, inputSnapshot, sessionId, rows, contextLength, contextEstimated, provider, model, emulationId, inputMode, toast, spinnerLabel, spinnerFrame, debug, expandToolOutputs]);
 
   const showToast = useCallback((message: string) => {
     setToast(message);
@@ -601,22 +711,66 @@ export const App: React.FC = () => {
 
   useMirror(layoutTree, inputBus);
 
+  // Compute messages for Static (completed) vs live (streaming)
+  // Static component handles deduplication by key - it only renders new items
+  const { staticMessages, streamingMessage } = useMemo(() => {
+    if (!scrollback) {
+      return { staticMessages: [], streamingMessage: null };
+    }
+
+    // Completed messages go to Static (rendered once, kept in scrollback)
+    const completed = messages.filter(m => !m.isStreaming);
+    // Streaming message stays in live section (can update)
+    const streaming = messages.find(m => m.isStreaming) || null;
+
+    return {
+      staticMessages: completed,
+      streamingMessage: streaming
+    };
+  }, [messages, scrollback]);
+
   return (
-    <FullScreen debug={debug}>
-      <Header version="0.1.0" debug={debug} />
-      
-      <MessageList 
-        messages={messages} 
-        height={contentHeight}
-        debug={debug}
-        expandToolOutputs={expandToolOutputs}
+    <FullScreen debug={debug} scrollback={scrollback}>
+      {!scrollback && <Header version={getVersion()} debug={debug} />}
+
+      {scrollback ? (
+        <Box flexDirection="column">
+          {/* Static: each message rendered ONCE, stays in scrollback buffer */}
+          <Static items={staticMessages}>
+            {(msg: Message) => (
+              <Box key={msg.id} flexDirection="column">
+                <SingleMessage message={msg} expandToolOutputs={expandToolOutputs} />
+              </Box>
+            )}
+          </Static>
+
+          {/* Live section: streaming message can update */}
+          {streamingMessage && (
+            <SingleMessage message={streamingMessage} expandToolOutputs={expandToolOutputs} />
+          )}
+        </Box>
+      ) : (
+        <MessageList
+          messages={messages}
+          height={contentHeight}
+          debug={debug}
+          expandToolOutputs={expandToolOutputs}
+          scrollback={scrollback}
+        />
+      )}
+
+      <ActivityLine
+        state={agentState}
+        spinnerLabel={spinnerLabel}
+        spinnerFrame={spinnerFrame}
+        inputMode={inputMode}
       />
-      
+
       <InputArea 
         onSubmit={handleSubmit}
         onCommand={handleCommand}
         commands={commands}
-        onStateChange={mirrorEnabled ? setInputSnapshot : undefined}
+        onStateChange={setInputSnapshot}
         onToast={showToast}
         cols={columns}
         inputBus={inputBus}
@@ -630,11 +784,11 @@ export const App: React.FC = () => {
           'Type a message or /help for commands...'
         }
       />
-      
+
       <StatusBar 
         state={agentState} 
         sessionId={sessionId}
-        version="0.1.0"
+        version={getVersion()}
         connectionStatus={configStore.hasApiKey() ? 'connected' : 'disconnected'}
         contextLength={contextLength}
         contextEstimated={contextEstimated}

package/src/agent/agent.ts

@@ -22,6 +22,7 @@ export interface AgentConfig {
   backend?: AgentBackend;
   policy?: Policy;
   tracer?: Tracer;
+  cwd?: string;  // Working directory for tool execution
 }
 
 export class AgentError extends Error {
@@ -42,10 +43,11 @@ export class Agent {
   private policy: Policy;
   private tracer: Tracer;
   private streamChunkSize = 32;
-  
+  private _cwd: string;
+
   constructor(config: AgentConfig = {}) {
     const apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY || '';
-    
+
     this.config = {
       model: config.model || 'claude-opus-4-20250514',
       apiKey,
@@ -56,18 +58,28 @@ export class Agent {
       systemPrompt: config.systemPrompt || this.getDefaultSystemPrompt(),
       backend: config.backend || new AnthropicBackend({ apiKey, apiEndpoint: config.apiEndpoint }),
       policy: config.policy || new AllowAllPolicy(),
-      tracer: config.tracer || new NoopTracer()
+      tracer: config.tracer || new NoopTracer(),
+      cwd: config.cwd || process.cwd()
     };
 
     this.backend = this.config.backend;
     this.policy = this.config.policy;
     this.tracer = this.config.tracer;
+    this._cwd = this.config.cwd;
   }
 
   hasApiKey(): boolean {
     return !!this.config.apiKey && this.config.apiKey.length > 0;
   }
 
+  setCwd(cwd: string): void {
+    this._cwd = cwd;
+  }
+
+  getCwd(): string {
+    return this._cwd;
+  }
+
   private getDefaultSystemPrompt(): string {
     return `You are ZTC (Zerg Terminal Client), an AI assistant that helps users interact with the Zerg continual AI system and manage local development tasks.
 
@@ -97,7 +109,14 @@ When a user intent maps to an available slash command, invoke the command direct
   // Convert messages to API format
   private formatMessages(messages: Message[]): LlmMessage[] {
     return messages
-      .filter((m): m is Message & { role: 'user' | 'assistant' } => m.role === 'user' || m.role === 'assistant')
+      .filter((m): m is Message & { role: 'user' | 'assistant' } => {
+        // Only include user and assistant messages
+        if (m.role !== 'user' && m.role !== 'assistant') return false;
+        // Filter out assistant messages with empty content (from tool-only responses)
+        // The API rejects empty content for non-final assistant messages
+        if (m.role === 'assistant' && (!m.content || m.content.trim() === '')) return false;
+        return true;
+      })
       .map(m => ({
         role: m.role,
         content: m.role === 'user' ? this.buildContentBlocks(m.content) : m.content
@@ -336,9 +355,10 @@ When a user intent maps to an available slash command, invoke the command direct
 
           try {
             const result = await executeTool(
-              toolBlock.name, 
+              toolBlock.name,
               toolBlock.input,
-              this.config.tools
+              this.config.tools,
+              { cwd: this._cwd }
             );
             
             toolCall.status = 'complete';

package/src/agent/commands/config.ts

@@ -1,9 +1,10 @@
 import { Command } from './types.js';
+import { DEFAULT_SPINNER_VERBS, formatSpinnerVerbs, parseSpinnerVerbs } from '../../utils/spinner_verbs.js';
 
 export const configCommand: Command = {
   name: 'config',
   description: 'Manage configuration',
-  usage: '<show|key|provider|endpoint|model> [value]',
+  usage: '<show|key|provider|endpoint|model|spinner> [value]',
   handler: async (args, ctx) => {
     const [subCmd, ...rest] = args;
     const value = rest.join(' ');
@@ -24,6 +25,7 @@ export const configCommand: Command = {
             `  Max Tokens: ${config.maxTokens}`,
             `  Zerg Endpoint: ${config.zergEndpoint || '(not set)'}`,
             `  Emulation: ${ctx.config.getEmulationId() || '(none)'}`,
+            `  Spinner verbs: ${formatSpinnerVerbs(config.spinnerVerbs || DEFAULT_SPINNER_VERBS)}`,
             '',
             `Config storage: ${ctx.config.locationLabel || '~/.ztc/config.json'}`
           ].join('\n')
@@ -120,10 +122,82 @@ export const configCommand: Command = {
         });
         break;
 
+      case 'spinner': {
+        const [action, ...restParts] = rest;
+        const actionValue = restParts.join(' ');
+        const current = ctx.config.get().spinnerVerbs || DEFAULT_SPINNER_VERBS;
+
+        if (!action || action === 'show') {
+          ctx.addMessage({
+            role: 'system',
+            content: `Spinner verbs:\n  ${formatSpinnerVerbs(current)}\n\nUsage:\n  /config spinner show\n  /config spinner set <verb1, verb2, ...>\n  /config spinner add <verb>\n  /config spinner remove <verb>\n  /config spinner reset\n  /config spinner off`
+          });
+          return;
+        }
+
+        if (action === 'reset') {
+          ctx.config.set('spinnerVerbs', DEFAULT_SPINNER_VERBS);
+          ctx.config.save();
+          ctx.addMessage({ role: 'system', content: '✓ Spinner verbs reset to defaults.' });
+          return;
+        }
+
+        if (action === 'off') {
+          ctx.config.set('spinnerVerbs', []);
+          ctx.config.save();
+          ctx.addMessage({ role: 'system', content: '✓ Spinner verbs disabled.' });
+          return;
+        }
+
+        if (action === 'set') {
+          const verbs = parseSpinnerVerbs(actionValue);
+          if (verbs.length === 0) {
+            ctx.addMessage({ role: 'system', content: 'Usage: /config spinner set <verb1, verb2, ...>' });
+            return;
+          }
+          ctx.config.set('spinnerVerbs', verbs);
+          ctx.config.save();
+          ctx.addMessage({ role: 'system', content: `✓ Spinner verbs updated: ${formatSpinnerVerbs(verbs)}` });
+          return;
+        }
+
+        if (action === 'add') {
+          const verbs = parseSpinnerVerbs(actionValue);
+          if (verbs.length === 0) {
+            ctx.addMessage({ role: 'system', content: 'Usage: /config spinner add <verb>' });
+            return;
+          }
+          const next = [...current, ...verbs];
+          ctx.config.set('spinnerVerbs', next);
+          ctx.config.save();
+          ctx.addMessage({ role: 'system', content: `✓ Added spinner verbs: ${formatSpinnerVerbs(verbs)}` });
+          return;
+        }
+
+        if (action === 'remove') {
+          const verbs = parseSpinnerVerbs(actionValue).map(v => v.toLowerCase());
+          if (verbs.length === 0) {
+            ctx.addMessage({ role: 'system', content: 'Usage: /config spinner remove <verb>' });
+            return;
+          }
+          const next = current.filter(v => !verbs.includes(v.toLowerCase()));
+          ctx.config.set('spinnerVerbs', next);
+          ctx.config.save();
+          ctx.addMessage({ role: 'system', content: `✓ Removed spinner verbs: ${formatSpinnerVerbs(verbs)}` });
+          return;
+        }
+
+        ctx.addMessage({
+          role: 'system',
+          content: 'Usage: /config spinner <show|set|add|remove|reset|off> [value]'
+        });
+        break;
+      }
+
       default:
         ctx.addMessage({
           role: 'system',
-          content: 'Usage: /config <show|key|provider|endpoint|model> [value]\n\nExamples:\n  /config show                           Show current config\n  /config key sk-ant-...                  Set API key (current provider)\n  /config key openai sk-...               Set API key for provider\n  /config provider openai                 Set provider\n  /config endpoint https://api.example.com/v1  Set OpenAI-compatible base URL\n  /config model claude-opus-4-20250514    Set model'
+          content: 'Usage: /config <show|key|provider|endpoint|model|spinner> [value]\n\nExamples:\n  /config show                           Show current config\n  /config key sk-ant-...                  Set API key (current provider)\n  /config key openai sk-...               Set API key for provider\n  /config provider openai                 Set provider\n  /config endpoint https://api.example.com/v1  Set OpenAI-compatible base URL\n  /config model claude-opus-4-20250514    Set model\n  /config spinner set Reticulating splines, Organizing thoughts'
         });
     }
   }

package/src/agent/commands/index.ts

@@ -14,6 +14,7 @@ import { skillsCommand } from './skills.js';
 import { retryCommand } from './retry.js';
 import { inputModeCommand } from './input_mode.js';
 import { keybindingsCommand } from './keybindings.js';
+import { updateCommand } from './update.js';
 import { Command } from './types.js';
 
 const commandList: Command[] = [];
@@ -35,6 +36,7 @@ commandList.push(
   permissionsCommand,
   skillsCommand,
   keybindingsCommand,
+  updateCommand,
   inputModeCommand,
   retryCommand,
   exitCommand

package/src/agent/commands/update.ts

@@ -0,0 +1,32 @@
+import { Command } from './types.js';
+import { getVersion } from '../../utils/version.js';
+import { checkForUpdate } from '../../utils/update.js';
+
+export const updateCommand: Command = {
+  name: 'update',
+  description: 'Check for updates and install the latest version',
+  handler: async (_args, ctx) => {
+    try {
+      ctx.addMessage({ role: 'system', content: 'Checking for updates...' });
+      const current = getVersion();
+      const info = await checkForUpdate(current);
+      if (!info.hasUpdate) {
+        ctx.addMessage({ role: 'system', content: `ZTC is up to date (v${current}).` });
+        return;
+      }
+      ctx.addMessage({ role: 'system', content: `Updating to v${info.latest}...` });
+      const result = await ctx.shell.run('npm install -g zerg-ztc@latest');
+      if (result.exitCode === 0) {
+        ctx.addMessage({ role: 'system', content: `✓ Updated to v${info.latest}. Restart ZTC to use the new version.` });
+      } else {
+        ctx.addMessage({
+          role: 'system',
+          content: `Update failed (exit ${result.exitCode}).\n${result.stderr || result.stdout || ''}`.trim()
+        });
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Update failed';
+      ctx.addMessage({ role: 'system', content: `Update failed: ${message}` });
+    }
+  }
+};