grokcodecli 0.1.0

package/src/conversation/history.ts

@@ -0,0 +1,131 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { GrokMessage } from '../grok/client.js';
+
+export interface ConversationSession {
+  id: string;
+  title: string;
+  createdAt: string;
+  updatedAt: string;
+  workingDirectory: string;
+  messages: GrokMessage[];
+}
+
+export class HistoryManager {
+  private historyDir: string;
+
+  constructor() {
+    this.historyDir = path.join(os.homedir(), '.config', 'grokcodecli', 'history');
+  }
+
+  private async ensureDir(): Promise<void> {
+    await fs.mkdir(this.historyDir, { recursive: true });
+  }
+
+  private generateId(): string {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+
+  private getSessionPath(id: string): string {
+    return path.join(this.historyDir, `${id}.json`);
+  }
+
+  async createSession(workingDirectory: string): Promise<ConversationSession> {
+    await this.ensureDir();
+
+    const session: ConversationSession = {
+      id: this.generateId(),
+      title: 'New Conversation',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      workingDirectory,
+      messages: [],
+    };
+
+    await this.saveSession(session);
+    return session;
+  }
+
+  async saveSession(session: ConversationSession): Promise<void> {
+    await this.ensureDir();
+    session.updatedAt = new Date().toISOString();
+
+    // Generate title from first user message if not set
+    if (session.title === 'New Conversation' && session.messages.length > 1) {
+      const firstUserMsg = session.messages.find(m => m.role === 'user');
+      if (firstUserMsg) {
+        session.title = firstUserMsg.content.slice(0, 50) + (firstUserMsg.content.length > 50 ? '...' : '');
+      }
+    }
+
+    await fs.writeFile(
+      this.getSessionPath(session.id),
+      JSON.stringify(session, null, 2),
+      'utf-8'
+    );
+  }
+
+  async loadSession(id: string): Promise<ConversationSession | null> {
+    try {
+      const content = await fs.readFile(this.getSessionPath(id), 'utf-8');
+      return JSON.parse(content) as ConversationSession;
+    } catch {
+      return null;
+    }
+  }
+
+  async listSessions(limit: number = 20): Promise<ConversationSession[]> {
+    await this.ensureDir();
+
+    try {
+      const files = await fs.readdir(this.historyDir);
+      const sessions: ConversationSession[] = [];
+
+      for (const file of files) {
+        if (!file.endsWith('.json')) continue;
+
+        try {
+          const content = await fs.readFile(path.join(this.historyDir, file), 'utf-8');
+          sessions.push(JSON.parse(content));
+        } catch {
+          // Skip invalid files
+        }
+      }
+
+      // Sort by updatedAt, newest first
+      sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+
+      return sessions.slice(0, limit);
+    } catch {
+      return [];
+    }
+  }
+
+  async deleteSession(id: string): Promise<boolean> {
+    try {
+      await fs.unlink(this.getSessionPath(id));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async getLastSession(): Promise<ConversationSession | null> {
+    const sessions = await this.listSessions(1);
+    return sessions.length > 0 ? sessions[0] : null;
+  }
+
+  async clearAll(): Promise<void> {
+    try {
+      const files = await fs.readdir(this.historyDir);
+      for (const file of files) {
+        if (file.endsWith('.json')) {
+          await fs.unlink(path.join(this.historyDir, file));
+        }
+      }
+    } catch {
+      // Ignore errors
+    }
+  }
+}

package/src/grok/client.ts

@@ -0,0 +1,192 @@
+/**
+ * Grok API Client
+ *
+ * xAI's Grok API is OpenAI-compatible, so we use similar patterns.
+ * API Base: https://api.x.ai/v1
+ */
+
+export interface GrokMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string;
+  tool_calls?: ToolCall[];
+  tool_call_id?: string;
+}
+
+export interface ToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+export interface Tool {
+  type: 'function';
+  function: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  };
+}
+
+export interface GrokCompletionRequest {
+  model: string;
+  messages: GrokMessage[];
+  tools?: Tool[];
+  tool_choice?: 'auto' | 'none' | { type: 'function'; function: { name: string } };
+  stream?: boolean;
+  temperature?: number;
+  max_tokens?: number;
+}
+
+export interface GrokCompletionResponse {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: {
+    index: number;
+    message: GrokMessage;
+    finish_reason: 'stop' | 'tool_calls' | 'length';
+  }[];
+  usage: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+export interface StreamChunk {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: {
+    index: number;
+    delta: Partial<GrokMessage>;
+    finish_reason: 'stop' | 'tool_calls' | 'length' | null;
+  }[];
+}
+
+export class GrokClient {
+  private apiKey: string;
+  private baseUrl: string = 'https://api.x.ai/v1';
+  public model: string;
+
+  constructor(apiKey: string, model: string = 'grok-4-0709') {
+    this.apiKey = apiKey;
+    this.model = model;
+  }
+
+  async chat(
+    messages: GrokMessage[],
+    tools?: Tool[],
+    options: { stream?: boolean; temperature?: number; maxTokens?: number } = {}
+  ): Promise<GrokCompletionResponse> {
+    const request: GrokCompletionRequest = {
+      model: this.model,
+      messages,
+      stream: false,
+      temperature: options.temperature ?? 0.7,
+      max_tokens: options.maxTokens ?? 16384,
+    };
+
+    if (tools && tools.length > 0) {
+      request.tools = tools;
+      request.tool_choice = 'auto';
+    }
+
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify(request),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Grok API error: ${response.status} - ${error}`);
+    }
+
+    return response.json() as Promise<GrokCompletionResponse>;
+  }
+
+  async *chatStream(
+    messages: GrokMessage[],
+    tools?: Tool[],
+    options: { temperature?: number; maxTokens?: number } = {}
+  ): AsyncGenerator<StreamChunk> {
+    const request: GrokCompletionRequest = {
+      model: this.model,
+      messages,
+      stream: true,
+      temperature: options.temperature ?? 0.7,
+      max_tokens: options.maxTokens ?? 16384,
+    };
+
+    if (tools && tools.length > 0) {
+      request.tools = tools;
+      request.tool_choice = 'auto';
+    }
+
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify(request),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Grok API error: ${response.status} - ${error}`);
+    }
+
+    const reader = response.body?.getReader();
+    if (!reader) throw new Error('No response body');
+
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed === 'data: [DONE]') continue;
+        if (trimmed.startsWith('data: ')) {
+          try {
+            const chunk = JSON.parse(trimmed.slice(6)) as StreamChunk;
+            yield chunk;
+          } catch {
+            // Ignore parse errors for incomplete chunks
+          }
+        }
+      }
+    }
+  }
+
+  async listModels(): Promise<string[]> {
+    const response = await fetch(`${this.baseUrl}/models`, {
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to list models: ${response.status}`);
+    }
+
+    const data = await response.json() as { data: { id: string }[] };
+    return data.data.map((m) => m.id);
+  }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+// Grok Code CLI - Public API exports
+
+export { GrokClient, type GrokMessage, type Tool, type ToolCall } from './grok/client.js';
+export { GrokChat, type ChatOptions } from './conversation/chat.js';
+export { HistoryManager, type ConversationSession } from './conversation/history.js';
+export { ConfigManager } from './config/manager.js';
+export { PermissionManager, type PermissionRequest, type ToolRiskLevel } from './permissions/manager.js';
+export { allTools, executeTool, type ToolResult } from './tools/registry.js';

package/src/permissions/manager.ts

@@ -0,0 +1,208 @@
+import * as readline from 'readline';
+import chalk from 'chalk';
+
+export type ToolRiskLevel = 'read' | 'write' | 'execute';
+
+export interface PermissionRequest {
+  tool: string;
+  description: string;
+  riskLevel: ToolRiskLevel;
+  details?: Record<string, unknown>;
+}
+
+export interface PermissionConfig {
+  autoApprove: string[];  // Tools to auto-approve
+  alwaysDeny: string[];   // Tools to always deny
+  sessionApproved: Set<string>;  // Approved for this session
+}
+
+const TOOL_RISK_LEVELS: Record<string, ToolRiskLevel> = {
+  Read: 'read',
+  Glob: 'read',
+  Grep: 'read',
+  Write: 'write',
+  Edit: 'write',
+  Bash: 'execute',
+  WebFetch: 'read',
+};
+
+const RISK_COLORS = {
+  read: chalk.green,
+  write: chalk.yellow,
+  execute: chalk.red,
+};
+
+const RISK_ICONS = {
+  read: '📖',
+  write: '✏️',
+  execute: '⚡',
+};
+
+export class PermissionManager {
+  private config: PermissionConfig;
+  private rl: readline.Interface | null = null;
+
+  constructor(autoApprove: string[] = []) {
+    this.config = {
+      autoApprove,
+      alwaysDeny: [],
+      sessionApproved: new Set(),
+    };
+  }
+
+  setReadlineInterface(rl: readline.Interface): void {
+    this.rl = rl;
+  }
+
+  async requestPermission(request: PermissionRequest): Promise<boolean> {
+    const { tool, description, riskLevel, details } = request;
+
+    // Check if always denied
+    if (this.config.alwaysDeny.includes(tool)) {
+      console.log(chalk.red(`\n⛔ Tool "${tool}" is blocked by configuration.\n`));
+      return false;
+    }
+
+    // Check if auto-approved
+    if (this.config.autoApprove.includes(tool) || this.config.autoApprove.includes('*')) {
+      return true;
+    }
+
+    // Check if approved for this session
+    const sessionKey = this.getSessionKey(tool, details);
+    if (this.config.sessionApproved.has(sessionKey)) {
+      return true;
+    }
+
+    // Read-only operations can be auto-approved with lower risk
+    if (riskLevel === 'read' && this.config.autoApprove.includes('read')) {
+      return true;
+    }
+
+    // Prompt user for permission
+    return this.promptUser(request);
+  }
+
+  private async promptUser(request: PermissionRequest): Promise<boolean> {
+    const { tool, description, riskLevel, details } = request;
+    const color = RISK_COLORS[riskLevel];
+    const icon = RISK_ICONS[riskLevel];
+
+    console.log(chalk.cyan('\n┌─────────────────────────────────────────────────────┐'));
+    console.log(chalk.cyan('│') + ` ${icon} ${color(`Permission Request: ${tool}`)}`.padEnd(60) + chalk.cyan('│'));
+    console.log(chalk.cyan('├─────────────────────────────────────────────────────┤'));
+    console.log(chalk.cyan('│') + ` ${description}`.padEnd(52) + chalk.cyan('│'));
+
+    // Show details
+    if (details) {
+      console.log(chalk.cyan('├─────────────────────────────────────────────────────┤'));
+      for (const [key, value] of Object.entries(details)) {
+        const valueStr = typeof value === 'string'
+          ? value.length > 45 ? value.slice(0, 42) + '...' : value
+          : String(value);
+        console.log(chalk.cyan('│') + chalk.gray(` ${key}: `) + valueStr.padEnd(42 - key.length) + chalk.cyan('│'));
+      }
+    }
+
+    console.log(chalk.cyan('└─────────────────────────────────────────────────────┘'));
+    console.log();
+    console.log(`  ${chalk.green('[y]')} Yes, allow once`);
+    console.log(`  ${chalk.green('[a]')} Allow for this session`);
+    console.log(`  ${chalk.red('[n]')} No, deny`);
+    console.log(`  ${chalk.red('[!]')} Deny and block for session`);
+    console.log();
+
+    const answer = await this.question(chalk.cyan('Choice [y/a/n/!]: '));
+    const choice = answer.toLowerCase().trim();
+
+    switch (choice) {
+      case 'y':
+      case 'yes':
+        return true;
+
+      case 'a':
+      case 'always':
+        this.config.sessionApproved.add(this.getSessionKey(tool, details));
+        console.log(chalk.green(`✓ "${tool}" approved for this session.\n`));
+        return true;
+
+      case 'n':
+      case 'no':
+      case '':
+        console.log(chalk.yellow('⊘ Denied.\n'));
+        return false;
+
+      case '!':
+      case 'block':
+        this.config.alwaysDeny.push(tool);
+        console.log(chalk.red(`⛔ "${tool}" blocked for this session.\n`));
+        return false;
+
+      default:
+        console.log(chalk.gray('Invalid choice, defaulting to deny.\n'));
+        return false;
+    }
+  }
+
+  private getSessionKey(tool: string, details?: Record<string, unknown>): string {
+    // For some tools, scope approval to specific paths/commands
+    if (tool === 'Bash' && details?.command) {
+      // Approve specific command patterns
+      const cmd = String(details.command);
+      if (cmd.startsWith('git ')) return `${tool}:git`;
+      if (cmd.startsWith('npm ')) return `${tool}:npm`;
+      if (cmd.startsWith('ls ') || cmd === 'ls') return `${tool}:ls`;
+      return tool;
+    }
+
+    if ((tool === 'Read' || tool === 'Write' || tool === 'Edit') && details?.file_path) {
+      // Could scope to directory
+      return tool;
+    }
+
+    return tool;
+  }
+
+  private question(prompt: string): Promise<string> {
+    return new Promise((resolve) => {
+      if (this.rl) {
+        this.rl.question(prompt, resolve);
+      } else {
+        // Fallback if no readline interface
+        const tempRl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout,
+        });
+        tempRl.question(prompt, (answer) => {
+          tempRl.close();
+          resolve(answer);
+        });
+      }
+    });
+  }
+
+  getToolRiskLevel(tool: string): ToolRiskLevel {
+    return TOOL_RISK_LEVELS[tool] || 'execute';
+  }
+
+  formatToolDetails(tool: string, params: Record<string, unknown>): string {
+    switch (tool) {
+      case 'Read':
+        return `Read file: ${params.file_path}`;
+      case 'Write':
+        return `Write to file: ${params.file_path}`;
+      case 'Edit':
+        return `Edit file: ${params.file_path}`;
+      case 'Bash':
+        return `Execute command: ${params.command}`;
+      case 'Glob':
+        return `Search for files: ${params.pattern}`;
+      case 'Grep':
+        return `Search in files: ${params.pattern}`;
+      case 'WebFetch':
+        return `Fetch URL: ${params.url}`;
+      default:
+        return `Execute ${tool}`;
+    }
+  }
+}

package/src/tools/bash.ts

@@ -0,0 +1,119 @@
+import { spawn } from 'child_process';
+import { ToolResult } from './registry.js';
+import { validateCommand, sanitizeOutput } from '../utils/security.js';
+import chalk from 'chalk';
+
+export interface BashToolParams {
+  command: string;
+  timeout?: number;
+  cwd?: string;
+}
+
+// Maximum output size to prevent memory issues
+const MAX_OUTPUT_SIZE = 1024 * 1024; // 1MB
+
+export async function bashTool(params: BashToolParams): Promise<ToolResult> {
+  const timeout = params.timeout ?? 120000; // 2 minutes default
+
+  // Security validation
+  const security = validateCommand(params.command);
+  if (!security.allowed) {
+    return {
+      success: false,
+      output: '',
+      error: `Security: ${security.reason}${security.suggestion ? ` - ${security.suggestion}` : ''}`,
+    };
+  }
+
+  // Warn about risky commands but allow them
+  let warning = '';
+  if (security.severity === 'medium') {
+    warning = chalk.yellow(`⚠️ ${security.reason}\n`);
+  }
+
+  return new Promise((resolve) => {
+    let stdout = '';
+    let stderr = '';
+    let killed = false;
+    let outputTruncated = false;
+
+    const child = spawn('bash', ['-c', params.command], {
+      cwd: params.cwd || process.cwd(),
+      env: {
+        ...process.env,
+        // Prevent color codes from commands that might interfere
+        FORCE_COLOR: '0',
+        NO_COLOR: '1',
+      },
+    });
+
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill('SIGTERM');
+      // Force kill after 5 seconds if still running
+      setTimeout(() => {
+        try {
+          child.kill('SIGKILL');
+        } catch {
+          // Already dead
+        }
+      }, 5000);
+    }, timeout);
+
+    child.stdout.on('data', (data) => {
+      if (stdout.length < MAX_OUTPUT_SIZE) {
+        stdout += data.toString();
+      } else if (!outputTruncated) {
+        outputTruncated = true;
+        stdout += '\n... (output truncated)';
+      }
+    });
+
+    child.stderr.on('data', (data) => {
+      if (stderr.length < MAX_OUTPUT_SIZE) {
+        stderr += data.toString();
+      }
+    });
+
+    child.on('close', (code, signal) => {
+      clearTimeout(timer);
+
+      if (killed) {
+        resolve({
+          success: false,
+          output: sanitizeOutput(stdout),
+          error: `Command timed out after ${timeout / 1000}s and was terminated`,
+        });
+        return;
+      }
+
+      // Combine and sanitize output
+      let output = sanitizeOutput(stdout);
+      if (stderr && code !== 0) {
+        output += (output ? '\n' : '') + chalk.red('stderr: ') + sanitizeOutput(stderr);
+      }
+
+      if (code === 0) {
+        resolve({
+          success: true,
+          output: warning + (output.trim() || '(command completed with no output)'),
+        });
+      } else {
+        resolve({
+          success: false,
+          output: output.trim(),
+          error: sanitizeOutput(stderr.trim()) || `Command exited with code ${code}${signal ? ` (signal: ${signal})` : ''}`,
+        });
+      }
+    });
+
+    child.on('error', (error) => {
+      clearTimeout(timer);
+      resolve({
+        success: false,
+        output: '',
+        error: `Failed to execute command: ${error.message}`,
+      });
+    });
+  });
+}