@a3s-lab/code 0.1.0

package/dist/client.js

@@ -0,0 +1,830 @@
+/**
+ * A3S Code Agent gRPC Client
+ *
+ * Full implementation of the CodeAgentService interface.
+ */
+import * as grpc from '@grpc/grpc-js';
+import * as protoLoader from '@grpc/proto-loader';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { loadConfigFromFile, loadConfigFromDir } from './config.js';
+import { normalizeMessages, a3sResponseToOpenAI, a3sChunkToOpenAI, } from './openai-compat.js';
+// Get the directory of this module
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Proto file path
+const PROTO_PATH = join(__dirname, '..', 'proto', 'code_agent.proto');
+// Numeric enum values
+export const StorageType = {
+    STORAGE_TYPE_UNSPECIFIED: 0,
+    STORAGE_TYPE_MEMORY: 1,
+    STORAGE_TYPE_FILE: 2,
+};
+export const SessionLane = {
+    SESSION_LANE_UNKNOWN: 0,
+    SESSION_LANE_CONTROL: 1,
+    SESSION_LANE_QUERY: 2,
+    SESSION_LANE_EXECUTE: 3,
+    SESSION_LANE_GENERATE: 4,
+};
+export const TimeoutAction = {
+    TIMEOUT_ACTION_UNKNOWN: 0,
+    TIMEOUT_ACTION_REJECT: 1,
+    TIMEOUT_ACTION_AUTO_APPROVE: 2,
+};
+export const TaskHandlerMode = {
+    TASK_HANDLER_MODE_UNKNOWN: 0,
+    TASK_HANDLER_MODE_INTERNAL: 1,
+    TASK_HANDLER_MODE_EXTERNAL: 2,
+    TASK_HANDLER_MODE_HYBRID: 3,
+};
+export const CronJobStatusEnum = {
+    UNKNOWN: 0,
+    ACTIVE: 1,
+    PAUSED: 2,
+    RUNNING: 3,
+};
+export const CronExecutionStatusEnum = {
+    UNKNOWN: 0,
+    SUCCESS: 1,
+    FAILED: 2,
+    TIMEOUT: 3,
+    CANCELLED: 4,
+};
+// ============================================================================
+// A3sClient Class
+// ============================================================================
+/**
+ * A3S Code Agent gRPC Client
+ *
+ * Provides a TypeScript interface to all CodeAgentService RPCs.
+ *
+ * @example
+ * ```typescript
+ * // Create client with config directory
+ * const client = new A3sClient({ configDir: '/path/to/a3s' });
+ *
+ * // Create client with config file
+ * const client = new A3sClient({ configPath: '/path/to/config.json' });
+ *
+ * // Create client with explicit address
+ * const client = new A3sClient({ address: 'localhost:4088' });
+ * ```
+ */
+export class A3sClient {
+    client;
+    address;
+    configDir;
+    constructor(options = {}) {
+        this.configDir = options.configDir;
+        // Load config from file if specified
+        let fileConfig;
+        if (options.configPath) {
+            fileConfig = loadConfigFromFile(options.configPath);
+        }
+        else if (options.configDir) {
+            fileConfig = loadConfigFromDir(options.configDir);
+        }
+        // Determine address: explicit > config file > default
+        this.address = options.address || fileConfig?.address || 'localhost:4088';
+        // Load proto definition
+        const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
+            keepCase: false,
+            longs: String,
+            enums: String,
+            defaults: true,
+            oneofs: true,
+        });
+        const protoDescriptor = grpc.loadPackageDefinition(packageDefinition);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const a3s = protoDescriptor.a3s;
+        const CodeAgentService = a3s.code.agent.v1.CodeAgentService;
+        // Create credentials
+        const credentials = options.useTls
+            ? grpc.credentials.createSsl()
+            : grpc.credentials.createInsecure();
+        // Create client
+        this.client = new CodeAgentService(this.address, credentials);
+    }
+    /**
+     * Get the config directory path
+     */
+    getConfigDir() {
+        return this.configDir;
+    }
+    /**
+     * Get the server address
+     */
+    getAddress() {
+        return this.address;
+    }
+    /**
+     * Close the client connection
+     */
+    close() {
+        this.client.close();
+    }
+    // ==========================================================================
+    // Helper method for promisifying unary calls
+    // ==========================================================================
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    promisify(method, request) {
+        return new Promise((resolve, reject) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.client[method](request, (error, response) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(response);
+                }
+            });
+        });
+    }
+    // ==========================================================================
+    // Lifecycle Management
+    // ==========================================================================
+    /**
+     * Check the health status of the agent
+     */
+    async healthCheck() {
+        return this.promisify('healthCheck', {});
+    }
+    /**
+     * Get agent capabilities
+     */
+    async getCapabilities() {
+        return this.promisify('getCapabilities', {});
+    }
+    /**
+     * Initialize the agent with workspace and environment
+     */
+    async initialize(workspace, env) {
+        return this.promisify('initialize', { workspace, env: env || {} });
+    }
+    /**
+     * Shutdown the agent
+     */
+    async shutdown() {
+        return this.promisify('shutdown', {});
+    }
+    // ==========================================================================
+    // Session Management
+    // ==========================================================================
+    /**
+     * Create a new session
+     */
+    async createSession(config, sessionId, initialContext) {
+        return this.promisify('createSession', {
+            sessionId,
+            config,
+            initialContext: initialContext || [],
+        });
+    }
+    /**
+     * Destroy a session
+     */
+    async destroySession(sessionId) {
+        return this.promisify('destroySession', { sessionId });
+    }
+    /**
+     * List all sessions
+     */
+    async listSessions() {
+        return this.promisify('listSessions', {});
+    }
+    /**
+     * Get a specific session
+     */
+    async getSession(sessionId) {
+        return this.promisify('getSession', { sessionId });
+    }
+    /**
+     * Configure a session
+     */
+    async configureSession(sessionId, config) {
+        return this.promisify('configureSession', { sessionId, config });
+    }
+    /**
+     * Get messages from a session
+     */
+    async getMessages(sessionId, limit, offset) {
+        return this.promisify('getMessages', { sessionId, limit, offset });
+    }
+    // ==========================================================================
+    // Code Generation
+    // ==========================================================================
+    /**
+     * Generate a response (unary)
+     *
+     * Supports both A3S and OpenAI message formats:
+     * - A3S: { role: 'ROLE_USER', content: '...' }
+     * - OpenAI: { role: 'user', content: '...' }
+     */
+    async generate(sessionId, messages) {
+        const normalizedMessages = normalizeMessages(messages);
+        return this.promisify('generate', { sessionId, messages: normalizedMessages });
+    }
+    /**
+     * Generate a response (streaming)
+     *
+     * Supports both A3S and OpenAI message formats.
+     */
+    streamGenerate(sessionId, messages) {
+        const normalizedMessages = normalizeMessages(messages);
+        const call = this.client.streamGenerate({ sessionId, messages: normalizedMessages });
+        return this.streamToAsyncIterable(call);
+    }
+    /**
+     * Generate structured output (unary)
+     *
+     * Supports both A3S and OpenAI message formats.
+     */
+    async generateStructured(sessionId, messages, schema) {
+        const normalizedMessages = normalizeMessages(messages);
+        return this.promisify('generateStructured', { sessionId, messages: normalizedMessages, schema });
+    }
+    /**
+     * Generate structured output (streaming)
+     *
+     * Supports both A3S and OpenAI message formats.
+     */
+    streamGenerateStructured(sessionId, messages, schema) {
+        const normalizedMessages = normalizeMessages(messages);
+        const call = this.client.streamGenerateStructured({
+            sessionId,
+            messages: normalizedMessages,
+            schema,
+        });
+        return this.streamToAsyncIterable(call);
+    }
+    // ==========================================================================
+    // OpenAI-Compatible Methods
+    // ==========================================================================
+    /**
+     * Generate a response in OpenAI ChatCompletion format
+     *
+     * This method provides full OpenAI API compatibility.
+     *
+     * @example
+     * ```typescript
+     * const completion = await client.chatCompletion(sessionId, [
+     *   { role: 'user', content: 'Hello!' }
+     * ]);
+     * console.log(completion.choices[0].message.content);
+     * ```
+     */
+    async chatCompletion(sessionId, messages, options) {
+        const response = await this.generate(sessionId, messages);
+        return a3sResponseToOpenAI(response, options?.model);
+    }
+    /**
+     * Stream a response in OpenAI ChatCompletionChunk format
+     *
+     * This method provides full OpenAI API compatibility for streaming.
+     *
+     * @example
+     * ```typescript
+     * for await (const chunk of client.streamChatCompletion(sessionId, [
+     *   { role: 'user', content: 'Hello!' }
+     * ])) {
+     *   const content = chunk.choices[0].delta.content;
+     *   if (content) process.stdout.write(content);
+     * }
+     * ```
+     */
+    async *streamChatCompletion(sessionId, messages, options) {
+        for await (const chunk of this.streamGenerate(sessionId, messages)) {
+            yield a3sChunkToOpenAI(chunk, options?.model);
+        }
+    }
+    // ==========================================================================
+    // Skill Management
+    // ==========================================================================
+    /**
+     * Load a skill into a session
+     */
+    async loadSkill(sessionId, skillName, skillContent) {
+        return this.promisify('loadSkill', { sessionId, skillName, skillContent });
+    }
+    /**
+     * Unload a skill from a session
+     */
+    async unloadSkill(sessionId, skillName) {
+        return this.promisify('unloadSkill', { sessionId, skillName });
+    }
+    /**
+     * List available skills
+     */
+    async listSkills(sessionId) {
+        return this.promisify('listSkills', { sessionId });
+    }
+    /**
+     * Get Claude Code skills
+     */
+    async getClaudeCodeSkills(name) {
+        return this.promisify('getClaudeCodeSkills', { name });
+    }
+    // ==========================================================================
+    // Context Management
+    // ==========================================================================
+    /**
+     * Get context usage for a session
+     */
+    async getContextUsage(sessionId) {
+        return this.promisify('getContextUsage', { sessionId });
+    }
+    /**
+     * Compact context for a session
+     */
+    async compactContext(sessionId) {
+        return this.promisify('compactContext', { sessionId });
+    }
+    /**
+     * Clear context for a session
+     */
+    async clearContext(sessionId) {
+        return this.promisify('clearContext', { sessionId });
+    }
+    // ==========================================================================
+    // Event Streaming
+    // ==========================================================================
+    /**
+     * Subscribe to agent events
+     */
+    subscribeEvents(sessionId, eventTypes) {
+        const call = this.client.subscribeEvents({
+            sessionId,
+            eventTypes: eventTypes || [],
+        });
+        return this.streamToAsyncIterable(call);
+    }
+    // ==========================================================================
+    // Control Operations
+    // ==========================================================================
+    /**
+     * Cancel an operation
+     */
+    async cancel(sessionId, operationId) {
+        return this.promisify('cancel', { sessionId, operationId });
+    }
+    /**
+     * Pause a session
+     */
+    async pause(sessionId) {
+        return this.promisify('pause', { sessionId });
+    }
+    /**
+     * Resume a session
+     */
+    async resume(sessionId) {
+        return this.promisify('resume', { sessionId });
+    }
+    // ==========================================================================
+    // Human-in-the-Loop (HITL)
+    // ==========================================================================
+    /**
+     * Confirm or reject tool execution
+     */
+    async confirmToolExecution(sessionId, toolId, approved, reason) {
+        return this.promisify('confirmToolExecution', {
+            sessionId,
+            toolId,
+            approved,
+            reason,
+        });
+    }
+    /**
+     * Set confirmation policy for a session
+     */
+    async setConfirmationPolicy(sessionId, policy) {
+        return this.promisify('setConfirmationPolicy', { sessionId, policy });
+    }
+    /**
+     * Get confirmation policy for a session
+     */
+    async getConfirmationPolicy(sessionId) {
+        return this.promisify('getConfirmationPolicy', { sessionId });
+    }
+    // ==========================================================================
+    // External Task Handling
+    // ==========================================================================
+    /**
+     * Set lane handler configuration
+     */
+    async setLaneHandler(sessionId, lane, config) {
+        return this.promisify('setLaneHandler', { sessionId, lane, config });
+    }
+    /**
+     * Get lane handler configuration
+     */
+    async getLaneHandler(sessionId, lane) {
+        return this.promisify('getLaneHandler', { sessionId, lane });
+    }
+    /**
+     * Complete an external task
+     */
+    async completeExternalTask(sessionId, taskId, success, result, error) {
+        return this.promisify('completeExternalTask', {
+            sessionId,
+            taskId,
+            success,
+            result: result || '',
+            error: error || '',
+        });
+    }
+    /**
+     * List pending external tasks
+     */
+    async listPendingExternalTasks(sessionId) {
+        return this.promisify('listPendingExternalTasks', { sessionId });
+    }
+    // ==========================================================================
+    // Permission System
+    // ==========================================================================
+    /**
+     * Set permission policy for a session
+     */
+    async setPermissionPolicy(sessionId, policy) {
+        return this.promisify('setPermissionPolicy', { sessionId, policy });
+    }
+    /**
+     * Get permission policy for a session
+     */
+    async getPermissionPolicy(sessionId) {
+        return this.promisify('getPermissionPolicy', { sessionId });
+    }
+    /**
+     * Check permission for a tool call
+     */
+    async checkPermission(sessionId, toolName, args) {
+        return this.promisify('checkPermission', {
+            sessionId,
+            toolName,
+            arguments: args,
+        });
+    }
+    /**
+     * Add a permission rule
+     */
+    async addPermissionRule(sessionId, ruleType, rule) {
+        return this.promisify('addPermissionRule', { sessionId, ruleType, rule });
+    }
+    // ==========================================================================
+    // Todo/Task Tracking
+    // ==========================================================================
+    /**
+     * Get todos for a session
+     */
+    async getTodos(sessionId) {
+        return this.promisify('getTodos', { sessionId });
+    }
+    /**
+     * Set todos for a session
+     */
+    async setTodos(sessionId, todos) {
+        return this.promisify('setTodos', { sessionId, todos });
+    }
+    // ==========================================================================
+    // Provider Configuration
+    // ==========================================================================
+    /**
+     * List all providers
+     */
+    async listProviders() {
+        return this.promisify('listProviders', {});
+    }
+    /**
+     * Get a specific provider
+     */
+    async getProvider(name) {
+        return this.promisify('getProvider', { name });
+    }
+    /**
+     * Add a new provider
+     */
+    async addProvider(provider) {
+        return this.promisify('addProvider', { provider });
+    }
+    /**
+     * Update an existing provider
+     */
+    async updateProvider(provider) {
+        return this.promisify('updateProvider', { provider });
+    }
+    /**
+     * Remove a provider
+     */
+    async removeProvider(name) {
+        return this.promisify('removeProvider', { name });
+    }
+    /**
+     * Set the default model
+     */
+    async setDefaultModel(provider, model) {
+        return this.promisify('setDefaultModel', { provider, model });
+    }
+    /**
+     * Get the default model
+     */
+    async getDefaultModel() {
+        return this.promisify('getDefaultModel', {});
+    }
+    // ==========================================================================
+    // Planning & Goal Tracking
+    // ==========================================================================
+    /**
+     * Create an execution plan
+     */
+    async createPlan(sessionId, prompt, context) {
+        return this.promisify('createPlan', { sessionId, prompt, context });
+    }
+    /**
+     * Get an existing plan
+     */
+    async getPlan(sessionId, planId) {
+        return this.promisify('getPlan', { sessionId, planId });
+    }
+    /**
+     * Extract goal from prompt
+     */
+    async extractGoal(sessionId, prompt) {
+        return this.promisify('extractGoal', { sessionId, prompt });
+    }
+    /**
+     * Check if goal is achieved
+     */
+    async checkGoalAchievement(sessionId, goal, currentState) {
+        return this.promisify('checkGoalAchievement', {
+            sessionId,
+            goal,
+            currentState,
+        });
+    }
+    // ==========================================================================
+    // Memory System
+    // ==========================================================================
+    /**
+     * Store a memory item
+     */
+    async storeMemory(sessionId, memory) {
+        return this.promisify('storeMemory', { sessionId, memory });
+    }
+    /**
+     * Retrieve a memory by ID
+     */
+    async retrieveMemory(sessionId, memoryId) {
+        return this.promisify('retrieveMemory', { sessionId, memoryId });
+    }
+    /**
+     * Search memories
+     */
+    async searchMemories(sessionId, query, tags, limit, recentOnly, minImportance) {
+        return this.promisify('searchMemories', {
+            sessionId,
+            query,
+            tags: tags || [],
+            limit: limit || 10,
+            recentOnly: recentOnly || false,
+            minImportance,
+        });
+    }
+    /**
+     * Get memory statistics
+     */
+    async getMemoryStats(sessionId) {
+        return this.promisify('getMemoryStats', { sessionId });
+    }
+    /**
+     * Clear memories
+     */
+    async clearMemories(sessionId, clearLongTerm, clearShortTerm, clearWorking) {
+        return this.promisify('clearMemories', {
+            sessionId,
+            clearLongTerm: clearLongTerm || false,
+            clearShortTerm: clearShortTerm || false,
+            clearWorking: clearWorking || false,
+        });
+    }
+    // ==========================================================================
+    // MCP (Model Context Protocol) Methods
+    // ==========================================================================
+    /**
+     * Register an MCP server
+     */
+    async registerMcpServer(config) {
+        return this.promisify('registerMcpServer', { config });
+    }
+    /**
+     * Connect to an MCP server
+     */
+    async connectMcpServer(name) {
+        return this.promisify('connectMcpServer', { name });
+    }
+    /**
+     * Disconnect from an MCP server
+     */
+    async disconnectMcpServer(name) {
+        return this.promisify('disconnectMcpServer', { name });
+    }
+    /**
+     * List all MCP servers
+     */
+    async listMcpServers() {
+        return this.promisify('listMcpServers', {});
+    }
+    /**
+     * Get MCP tools
+     */
+    async getMcpTools(serverName) {
+        return this.promisify('getMcpTools', { serverName });
+    }
+    // ==========================================================================
+    // LSP (Language Server Protocol) Methods
+    // ==========================================================================
+    /**
+     * Start a language server for a specific language
+     */
+    async startLspServer(language, rootUri) {
+        return this.promisify('startLspServer', {
+            language,
+            rootUri: rootUri || '',
+        });
+    }
+    /**
+     * Stop a running language server
+     */
+    async stopLspServer(language) {
+        return this.promisify('stopLspServer', { language });
+    }
+    /**
+     * List all running language servers
+     */
+    async listLspServers() {
+        return this.promisify('listLspServers', {});
+    }
+    /**
+     * Get hover information at a specific position
+     */
+    async lspHover(filePath, line, column) {
+        return this.promisify('lspHover', {
+            filePath,
+            line,
+            column,
+        });
+    }
+    /**
+     * Go to definition at a specific position
+     */
+    async lspDefinition(filePath, line, column) {
+        return this.promisify('lspDefinition', {
+            filePath,
+            line,
+            column,
+        });
+    }
+    /**
+     * Find all references at a specific position
+     */
+    async lspReferences(filePath, line, column, includeDeclaration) {
+        return this.promisify('lspReferences', {
+            filePath,
+            line,
+            column,
+            includeDeclaration: includeDeclaration || false,
+        });
+    }
+    /**
+     * Search for symbols in the workspace
+     */
+    async lspSymbols(query, limit) {
+        return this.promisify('lspSymbols', {
+            query,
+            limit: limit || 20,
+        });
+    }
+    /**
+     * Get diagnostics for a file
+     */
+    async lspDiagnostics(filePath) {
+        return this.promisify('lspDiagnostics', {
+            filePath: filePath || '',
+        });
+    }
+    // ==========================================================================
+    // Cron (Scheduled Tasks)
+    // ==========================================================================
+    /**
+     * List all cron jobs
+     */
+    async listCronJobs() {
+        return this.promisify('listCronJobs', {});
+    }
+    /**
+     * Create a new cron job
+     * @param name Job name
+     * @param schedule Schedule expression (cron syntax or natural language)
+     * @param command Command to execute
+     * @param timeoutMs Execution timeout in milliseconds (default: 60000)
+     */
+    async createCronJob(name, schedule, command, timeoutMs) {
+        return this.promisify('createCronJob', {
+            name,
+            schedule,
+            command,
+            timeoutMs,
+        });
+    }
+    /**
+     * Get a cron job by ID or name
+     * @param id Job ID
+     * @param name Job name (alternative to ID)
+     */
+    async getCronJob(id, name) {
+        return this.promisify('getCronJob', { id, name });
+    }
+    /**
+     * Update a cron job
+     * @param id Job ID
+     * @param schedule New schedule expression
+     * @param command New command
+     * @param timeoutMs New timeout
+     */
+    async updateCronJob(id, schedule, command, timeoutMs) {
+        return this.promisify('updateCronJob', {
+            id,
+            schedule,
+            command,
+            timeoutMs,
+        });
+    }
+    /**
+     * Pause a cron job
+     * @param id Job ID
+     */
+    async pauseCronJob(id) {
+        return this.promisify('pauseCronJob', { id });
+    }
+    /**
+     * Resume a paused cron job
+     * @param id Job ID
+     */
+    async resumeCronJob(id) {
+        return this.promisify('resumeCronJob', { id });
+    }
+    /**
+     * Delete a cron job
+     * @param id Job ID
+     */
+    async deleteCronJob(id) {
+        return this.promisify('deleteCronJob', { id });
+    }
+    /**
+     * Get execution history for a cron job
+     * @param id Job ID
+     * @param limit Max records to return (default: 10)
+     */
+    async getCronHistory(id, limit) {
+        return this.promisify('getCronHistory', { id, limit });
+    }
+    /**
+     * Manually run a cron job
+     * @param id Job ID
+     */
+    async runCronJob(id) {
+        return this.promisify('runCronJob', { id });
+    }
+    /**
+     * Parse natural language schedule to cron expression
+     * @param input Natural language or cron expression
+     */
+    async parseCronSchedule(input) {
+        return this.promisify('parseCronSchedule', { input });
+    }
+    // ==========================================================================
+    // Helper: Convert gRPC stream to AsyncIterable
+    // ==========================================================================
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    streamToAsyncIterable(call) {
+        return {
+            [Symbol.asyncIterator]() {
+                return {
+                    next() {
+                        return new Promise((resolve, reject) => {
+                            call.once('data', (data) => {
+                                resolve({ value: data, done: false });
+                            });
+                            call.once('end', () => {
+                                resolve({ value: undefined, done: true });
+                            });
+                            call.once('error', (error) => {
+                                reject(error);
+                            });
+                        });
+                    },
+                };
+            },
+        };
+    }
+}
+//# sourceMappingURL=client.js.map