@webdevtoday/grok-cli/dist/types/index.d.ts

A sophisticated CLI tool for interacting with xAI Grok 4, featuring conversation history, file reference, custom commands, memory system, and genetic development workflows

/**
 * Core type definitions for Grok CLI
 */
export interface GrokConfig {
    model: string;
    apiKeys: {
        xai: string | undefined;
        openai: string | undefined;
        composio: string | undefined;
    };
    hooks: HookConfiguration;
    permissions: PermissionConfiguration;
    mcp: McpConfiguration;
    memory: MemoryConfiguration;
}
export interface HookConfiguration {
    [eventName: string]: HookMatcher[];
}
export interface HookMatcher {
    matcher?: string | undefined;
    hooks: HookCommand[];
}
export interface HookCommand {
    type: 'command';
    command: string;
    timeout?: number | undefined;
}
export interface HookEvent {
    sessionId: string;
    transcriptPath: string;
    cwd: string;
    hookEventName: HookEventName;
    toolName?: string;
    toolInput?: Record<string, unknown>;
    toolResponse?: Record<string, unknown>;
    prompt?: string;
    message?: string;
}
export type HookEventName = 'PreToolUse' | 'PostToolUse' | 'UserPromptSubmit' | 'Notification' | 'Stop' | 'SubagentStop' | 'PreCompact';
export interface HookResult {
    success: boolean;
    decision?: 'approve' | 'block';
    reason?: string;
    continue?: boolean;
    stopReason?: string;
    suppressOutput?: boolean;
}
export interface ToolResult {
    success: boolean;
    output: string;
    error?: string | undefined;
    metadata?: Record<string, unknown>;
}
export interface BaseTool {
    name: string;
    description: string;
    execute(params: Record<string, unknown>): Promise<ToolResult>;
    validatePermissions(permissions: PermissionManager, params: Record<string, unknown>): boolean;
}
export interface PermissionConfiguration {
    mode: PermissionMode;
    allowedTools: string[];
    disallowedTools: string[];
}
export type PermissionMode = 'ask' | 'plan' | 'auto' | 'full';
export interface PermissionManager {
    checkToolPermission(toolName: string, params: Record<string, unknown>): boolean;
    requestPermission(toolName: string, params: Record<string, unknown>): Promise<boolean>;
}
export interface McpConfiguration {
    servers: Record<string, McpServerConfig>;
}
export interface McpServerConfig {
    command: string;
    args: string[];
    env?: Record<string, string> | undefined;
    cwd?: string | undefined;
}
export interface McpServer {
    name: string;
    config: McpServerConfig;
    status: 'connected' | 'disconnected' | 'connecting' | 'error';
    tools: string[];
    prompts: string[];
}
export interface MemoryConfiguration {
    autoLoad: boolean;
    maxDepth: number;
    excludePatterns: string[];
}
export interface MemoryFile {
    path: string;
    content: string;
    imports: string[];
    type: 'user' | 'project' | 'local';
}
export interface Session {
    id: string;
    cwd: string;
    startTime: Date;
    config: GrokConfig;
    history: ChatMessage[];
    transcriptPath: string;
}
export interface ChatMessage {
    role: 'user' | 'assistant' | 'system';
    content: string;
    timestamp: Date;
    toolCalls?: ToolCall[];
}
export interface ToolCall {
    toolName: string;
    params: Record<string, unknown>;
    result: ToolResult;
    timestamp: Date;
}
export interface SlashCommand {
    name: string;
    description: string;
    scope: 'builtin' | 'project' | 'user' | 'mcp';
    execute(args: string[], context: CommandContext): Promise<CommandResult>;
}
export interface CommandContext {
    session: Session;
    config: GrokConfig;
    cwd: string;
    mcpClient?: any;
    memoryManager?: any;
}
export interface CommandResult {
    success: boolean;
    output?: string;
    error?: string;
}
export interface AgentConfig {
    model: string;
    apiKey: string;
    baseUrl?: string;
    temperature?: number;
    maxTokens?: number;
}
export declare class GrokError extends Error {
    code: string;
    details?: Record<string, unknown> | undefined;
    constructor(message: string, code: string, details?: Record<string, unknown> | undefined);
}
export declare class ConfigurationError extends GrokError {
    constructor(message: string, details?: Record<string, unknown>);
}
export declare class PermissionError extends GrokError {
    constructor(message: string, details?: Record<string, unknown>);
}
export declare class HookError extends GrokError {
    constructor(message: string, details?: Record<string, unknown>);
}
export declare class McpError extends GrokError {
    constructor(message: string, details?: Record<string, unknown>);
}
//# sourceMappingURL=index.d.ts.map