zerg-ztc 0.1.5 → 0.1.7

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/tools/file.ts

@@ -1,9 +1,14 @@
 import { readFile, writeFile, readdir, stat } from 'fs/promises';
 import { dirname, resolve } from 'path';
-import { Tool } from './types.js';
+import { Tool, ToolContext } from './types.js';
 import { ToolCapability } from '../runtime/capabilities.js';
 import { buildSimpleDiff } from '../../utils/diff.js';
 
+function resolvePath(path: string, context?: ToolContext): string {
+  const base = context?.cwd || process.cwd();
+  return resolve(base, path);
+}
+
 // --- File Tools ---
 
 export const readFileTool: Tool = {
@@ -27,10 +32,10 @@ export const readFileTool: Tool = {
       required: ['path']
     }
   },
-  execute: async (args) => {
-    const path = resolve(String(args.path));
+  execute: async (args, context) => {
+    const path = resolvePath(String(args.path), context);
     const encoding = (args.encoding as BufferEncoding) || 'utf-8';
-    
+
     try {
       const content = await readFile(path, { encoding });
       const stats = await stat(path);
@@ -70,16 +75,16 @@ export const writeFileTool: Tool = {
       required: ['path', 'content']
     }
   },
-  execute: async (args) => {
-    const path = resolve(String(args.path));
+  execute: async (args, context) => {
+    const path = resolvePath(String(args.path), context);
     const content = String(args.content);
     const append = args.append === 'true';
-    
+
     try {
       // Ensure directory exists
       const { mkdir, appendFile } = await import('fs/promises');
       await mkdir(dirname(path), { recursive: true });
-      
+
       let beforeContent = '';
       try {
         beforeContent = await readFile(path, { encoding: 'utf-8' });
@@ -92,7 +97,7 @@ export const writeFileTool: Tool = {
       } else {
         await writeFile(path, content, 'utf-8');
       }
-      
+
       const stats = await stat(path);
       const afterContent = await readFile(path, { encoding: 'utf-8' });
       const diff = buildSimpleDiff(beforeContent, afterContent);
@@ -131,38 +136,38 @@ export const listDirectoryTool: Tool = {
       required: ['path']
     }
   },
-  execute: async (args) => {
-    const path = resolve(String(args.path));
+  execute: async (args, context) => {
+    const path = resolvePath(String(args.path), context);
     const recursive = args.recursive === 'true';
-    
+
     async function listDir(dir: string, depth = 0): Promise<object[]> {
       if (depth > 3) return [];
-      
+
       const entries = await readdir(dir, { withFileTypes: true });
       const results: object[] = [];
-      
+
       for (const entry of entries.slice(0, 100)) { // Limit entries
         const entryPath = resolve(dir, entry.name);
         const info: Record<string, unknown> = {
           name: entry.name,
           type: entry.isDirectory() ? 'directory' : 'file'
         };
-        
+
         if (entry.isFile()) {
           const s = await stat(entryPath);
           info.size = s.size;
         }
-        
+
         if (recursive && entry.isDirectory() && !entry.name.startsWith('.')) {
           info.children = await listDir(entryPath, depth + 1);
         }
-        
+
         results.push(info);
       }
-      
+
       return results;
     }
-    
+
     try {
       const entries = await listDir(path);
       return JSON.stringify({ path, entries });

package/src/agent/tools/index.ts

@@ -1,4 +1,4 @@
-import { Tool } from './types.js';
+import { Tool, ToolContext } from './types.js';
 import { ToolDefinition } from '../../types.js';
 import { readFileTool, writeFileTool, listDirectoryTool } from './file.js';
 import { runCommandTool } from './shell.js';
@@ -27,15 +27,16 @@ export function getTool(name: string, tools: Tool[] = defaultTools): Tool | unde
 }
 
 export async function executeTool(
-  name: string, 
+  name: string,
   args: Record<string, unknown>,
-  tools: Tool[] = defaultTools
+  tools: Tool[] = defaultTools,
+  context?: ToolContext
 ): Promise<string> {
   const tool = getTool(name, tools);
   if (!tool) {
     throw new Error(`Unknown tool: ${name}`);
   }
-  return tool.execute(args);
+  return tool.execute(args, context);
 }
 
 export { readFileTool, writeFileTool, listDirectoryTool } from './file.js';

package/src/agent/tools/search.ts

@@ -1,6 +1,6 @@
 import { spawn } from 'child_process';
 import { resolve } from 'path';
-import { Tool } from './types.js';
+import { Tool, ToolContext } from './types.js';
 import { ToolCapability } from '../runtime/capabilities.js';
 
 interface RunResult {
@@ -58,9 +58,10 @@ export const searchTool: Tool = {
       required: ['pattern']
     }
   },
-  execute: async (args) => {
+  execute: async (args, context) => {
+    const baseCwd = context?.cwd || process.cwd();
     const pattern = String(args.pattern || '');
-    const path = resolve(String(args.path || '.'));
+    const path = resolve(baseCwd, String(args.path || '.'));
     const glob = args.glob ? String(args.glob) : undefined;
     const outputMode = args.output_mode === 'files' ? 'files' : 'content';
     const maxResults = Math.max(1, Math.min(200, parseInt(String(args.max_results || '20'), 10)));
@@ -82,14 +83,14 @@ export const searchTool: Tool = {
 
     let result: RunResult | null = null;
     try {
-      result = await runCommand('rg', rgArgs, process.cwd());
+      result = await runCommand('rg', rgArgs, baseCwd);
     } catch {
       result = null;
     }
 
     if (!result || (result.code !== 0 && result.code !== 1)) {
       const grepArgs = ['-R', '-n', pattern, path];
-      const fallback = await runCommand('grep', grepArgs, process.cwd());
+      const fallback = await runCommand('grep', grepArgs, baseCwd);
       if (fallback.code !== 0 && fallback.code !== 1) {
         throw new Error(fallback.stderr || 'Search failed');
       }

package/src/agent/tools/shell.ts

@@ -1,7 +1,7 @@
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { resolve } from 'path';
-import { Tool } from './types.js';
+import { Tool, ToolContext } from './types.js';
 import { ToolCapability } from '../runtime/capabilities.js';
 
 const execAsync = promisify(exec);
@@ -32,24 +32,25 @@ export const runCommandTool: Tool = {
       required: ['command']
     }
   },
-  execute: async (args) => {
+  execute: async (args, context) => {
     const command = String(args.command);
-    const cwd = args.cwd ? resolve(String(args.cwd)) : process.cwd();
+    const baseCwd = context?.cwd || process.cwd();
+    const cwd = args.cwd ? resolve(baseCwd, String(args.cwd)) : baseCwd;
     const timeout = parseInt(String(args.timeout || '30000'), 10);
-    
+
     // Basic safety checks
     const dangerous = ['rm -rf /', 'mkfs', ':(){:|:&};:'];
     if (dangerous.some(d => command.includes(d))) {
       throw new Error('Command rejected for safety reasons');
     }
-    
+
     try {
-      const { stdout, stderr } = await execAsync(command, { 
-        cwd, 
+      const { stdout, stderr } = await execAsync(command, {
+        cwd,
         timeout,
         maxBuffer: 1024 * 1024 // 1MB
       });
-      
+
       return JSON.stringify({
         command,
         cwd,
@@ -59,7 +60,10 @@ export const runCommandTool: Tool = {
       });
     } catch (err) {
       const e = err as Error & { stdout?: string; stderr?: string; code?: number };
-      throw new Error(`Command failed: ${e.message}\nstderr: ${e.stderr || ''}`);
+      // Include both stdout and stderr in error - many tools output errors to stdout
+      const output = [e.stdout, e.stderr].filter(Boolean).join('\n').trim();
+      const outputSnippet = output.slice(0, 2000) || '(no output)';
+      throw new Error(`Command failed (exit ${e.code || '?'}):\n${outputSnippet}`);
     }
   }
 };

package/src/agent/tools/types.ts

@@ -3,8 +3,12 @@ import { ToolCapability } from '../runtime/capabilities.js';
 
 // --- Tool Interface ---
 
+export interface ToolContext {
+  cwd: string;  // Working directory for path resolution
+}
+
 export interface Tool {
   definition: ToolDefinition;
   capabilities?: ToolCapability[];
-  execute: (args: Record<string, unknown>) => Promise<string>;
+  execute: (args: Record<string, unknown>, context?: ToolContext) => Promise<string>;
 }

package/src/components/InputArea.tsx

@@ -8,6 +8,7 @@ import { debugLog } from '../debug/logger.js';
 import chalk from 'chalk';
 import { saveClipboardImage } from '../utils/clipboard_image.js';
 import { renderImagePreview } from '../utils/image_preview.js';
+import { completePath } from '../utils/path_complete.js';
 import {
   createEmptyState,
   insertText,
@@ -40,6 +41,7 @@ interface InputAreaProps {
   placeholder?: string;
   historyEnabled?: boolean;
   debug?: boolean;
+  cwd?: string;  // Working directory for path tab completion
 }
 
 export type { InputState } from '../ui/core/input_state.js';
@@ -100,8 +102,8 @@ function reducer(state: InputState, action: InputAction): InputState {
   }
 }
 
-export const InputArea: React.FC<InputAreaProps> = ({ 
-  onSubmit, 
+export const InputArea: React.FC<InputAreaProps> = ({
+  onSubmit,
   onCommand,
   commands = [],
   onStateChange,
@@ -111,7 +113,8 @@ export const InputArea: React.FC<InputAreaProps> = ({
   disabled = false,
   placeholder = 'Type a message...',
   historyEnabled = true,
-  debug = false
+  debug = false,
+  cwd = process.cwd()
 }) => {
   const [state, dispatch] = useReducer(reducer, initialState);
   const stateRef = React.useRef(state);
@@ -279,6 +282,60 @@ export const InputArea: React.FC<InputAreaProps> = ({
     return { ...current, segments, cursor: { index: cursor.index, offset: replacedLeft.length }, historyIdx: -1 };
   }, []);
 
+  // Tab completion state
+  const tabCompletionAlternativesRef = React.useRef<string[]>([]);
+  const lastTabPrefixRef = React.useRef<string>('');
+
+  // Handle tab completion for shell commands
+  const handleTabComplete = useCallback(async (current: InputState): Promise<InputState> => {
+    const plainText = getPlainText(current.segments);
+
+    // Only complete if this looks like a shell command with a path
+    // Match: !cd path, !ls path, !cat path, etc.
+    const shellMatch = plainText.match(/^!(\w+)\s+(.*)$/);
+    if (!shellMatch) {
+      // Also support just !cd without a path yet
+      if (plainText.match(/^!cd\s*$/)) {
+        // Show home directory
+        const result = await completePath('~/', cwd);
+        if (result && result.alternatives.length > 0) {
+          tabCompletionAlternativesRef.current = result.alternatives;
+          onToast?.(`Completions: ${result.alternatives.slice(0, 5).join(', ')}${result.alternatives.length > 5 ? '...' : ''}`);
+        }
+      }
+      return current;
+    }
+
+    const partialPath = shellMatch[2];
+    const commandPrefix = `!${shellMatch[1]} `;
+
+    // Try to complete the path
+    const result = await completePath(partialPath, cwd);
+    if (!result) {
+      onToast?.('No completions');
+      return current;
+    }
+
+    // If we have alternatives and this is a repeat tab, show them
+    if (result.alternatives.length > 1) {
+      tabCompletionAlternativesRef.current = result.alternatives;
+      lastTabPrefixRef.current = partialPath;
+      onToast?.(`Completions: ${result.alternatives.slice(0, 6).join('  ')}${result.alternatives.length > 6 ? ' ...' : ''}`);
+    } else {
+      tabCompletionAlternativesRef.current = [];
+    }
+
+    // Update the input with the completed path
+    const newText = commandPrefix + result.completed;
+    const newSegments: InputSegment[] = [{ type: 'text', text: newText }];
+    return {
+      ...current,
+      segments: newSegments,
+      cursor: { index: 0, offset: newText.length },
+      historyIdx: -1
+    };
+  }, [cwd, onToast]);
+
   const inputRenderCount = React.useRef(0);
   React.useEffect(() => {
     inputRenderCount.current += 1;
@@ -599,6 +656,16 @@ export const InputArea: React.FC<InputAreaProps> = ({
       return;
     }
 
+    // Tab completion for shell commands
+    if (safeKey.tab || input === '\t') {
+      void handleTabComplete(state).then(nextState => {
+        if (nextState !== state) {
+          dispatch({ type: 'apply', state: nextState });
+        }
+      });
+      return;
+    }
+
     if (key.leftArrow) {
       if (key.ctrl) {
         dispatch({ type: 'apply', state: moveWordLeft(state) });

package/src/utils/path_complete.ts

@@ -0,0 +1,147 @@
+import { readdir } from 'fs/promises';
+import { resolve, dirname, basename } from 'path';
+import { homedir } from 'os';
+
+/**
+ * Get path completions for tab autocomplete
+ */
+export async function getPathCompletions(
+  partial: string,
+  cwd: string
+): Promise<string[]> {
+  // Expand tilde
+  let expandedPartial = partial;
+  if (partial.startsWith('~/')) {
+    expandedPartial = resolve(homedir(), partial.slice(2));
+  } else if (partial === '~') {
+    expandedPartial = homedir();
+  }
+
+  // Resolve the path relative to cwd
+  const fullPath = resolve(cwd, expandedPartial);
+
+  // Determine the directory to list and the prefix to match
+  let dirToList: string;
+  let prefix: string;
+
+  try {
+    const { stat } = await import('fs/promises');
+    const stats = await stat(fullPath);
+    if (stats.isDirectory()) {
+      // If it's a directory, list its contents
+      dirToList = fullPath;
+      prefix = '';
+    } else {
+      // It's a file, no completions
+      return [];
+    }
+  } catch {
+    // Path doesn't exist, so complete the last component
+    dirToList = dirname(fullPath);
+    prefix = basename(fullPath).toLowerCase();
+  }
+
+  try {
+    const entries = await readdir(dirToList, { withFileTypes: true });
+    const matches = entries
+      .filter(entry => entry.name.toLowerCase().startsWith(prefix))
+      .map(entry => {
+        const name = entry.name;
+        const suffix = entry.isDirectory() ? '/' : '';
+        return name + suffix;
+      })
+      .sort();
+
+    return matches;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Complete a partial path, returning the completed path or null if no unique completion
+ */
+export async function completePath(
+  partial: string,
+  cwd: string
+): Promise<{ completed: string; isDirectory: boolean; alternatives: string[] } | null> {
+  // Expand tilde for internal processing
+  let expandedPartial = partial;
+  let tildePrefix = '';
+  if (partial.startsWith('~/')) {
+    expandedPartial = resolve(homedir(), partial.slice(2));
+    tildePrefix = '~/';
+  } else if (partial === '~') {
+    return { completed: '~/', isDirectory: true, alternatives: [] };
+  }
+
+  const fullPath = resolve(cwd, expandedPartial);
+  let dirToList: string;
+  let prefix: string;
+  let basePath: string;
+
+  try {
+    const { stat } = await import('fs/promises');
+    const stats = await stat(fullPath);
+    if (stats.isDirectory()) {
+      // Already a complete directory, append /
+      if (!partial.endsWith('/')) {
+        return { completed: partial + '/', isDirectory: true, alternatives: [] };
+      }
+      // List directory contents for alternatives
+      dirToList = fullPath;
+      prefix = '';
+      basePath = partial;
+    } else {
+      // Complete file path
+      return { completed: partial, isDirectory: false, alternatives: [] };
+    }
+  } catch {
+    // Path doesn't exist, complete the last component
+    dirToList = dirname(fullPath);
+    prefix = basename(fullPath).toLowerCase();
+    basePath = tildePrefix ? tildePrefix + dirname(expandedPartial.slice(homedir().length + 1)) : dirname(partial);
+    if (basePath && !basePath.endsWith('/')) basePath += '/';
+    if (basePath === './') basePath = '';
+  }
+
+  try {
+    const entries = await readdir(dirToList, { withFileTypes: true });
+    const matches = entries
+      .filter(entry => entry.name.toLowerCase().startsWith(prefix))
+      .sort();
+
+    if (matches.length === 0) {
+      return null;
+    }
+
+    if (matches.length === 1) {
+      const entry = matches[0];
+      const suffix = entry.isDirectory() ? '/' : '';
+      const completed = basePath + entry.name + suffix;
+      return { completed, isDirectory: entry.isDirectory(), alternatives: [] };
+    }
+
+    // Find common prefix among all matches
+    const names = matches.map(e => e.name);
+    let commonPrefix = names[0];
+    for (const name of names.slice(1)) {
+      let i = 0;
+      while (i < commonPrefix.length && i < name.length && commonPrefix[i] === name[i]) {
+        i++;
+      }
+      commonPrefix = commonPrefix.slice(0, i);
+    }
+
+    const alternatives = matches.map(e => e.name + (e.isDirectory() ? '/' : ''));
+    const completed = basePath + commonPrefix;
+
+    return {
+      completed: completed.length > partial.length ? completed : partial,
+      isDirectory: false,
+      alternatives
+    };
+  } catch {
+    return null;
+  }
+}

package/src/utils/shell.ts

@@ -54,7 +54,16 @@ export async function runShellCommand(command: string, cwd: string): Promise<She
 
 export async function resolveWorkingDir(current: string, target?: string): Promise<string> {
   const base = current || process.cwd();
-  const next = target && target.trim().length > 0 ? resolve(base, target) : base;
+  let path = target?.trim() || '';
+
+  // Expand tilde to home directory
+  if (path.startsWith('~/')) {
+    path = resolve(process.env.HOME || '', path.slice(2));
+  } else if (path === '~') {
+    path = process.env.HOME || '';
+  }
+
+  const next = path.length > 0 ? resolve(base, path) : base;
   const info = await stat(next);
   if (!info.isDirectory()) {
     throw new Error('Not a directory');