acpreact 1.0.0 → 1.0.3

package/.github/workflows/publish.yml

@@ -21,6 +21,15 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
+      - name: Auto-bump version
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          npm version patch --no-git-tag-version
+          git add package.json package-lock.json
+          git commit -m "Auto-bump version [skip ci]"
+          git push
+
       - name: Publish to npm
         run: npm publish
         env:

package/README.md

@@ -1,13 +1,13 @@
 # acpreact - ACP SDK
 
-A clean, production-ready SDK for implementing ACP (AI Control Protocol) with function-based chat analysis.
+A lightweight SDK for setting up tools and managing ACP protocol communication. Allows opencode and kilo CLI to call registered tools via the ACP protocol.
 
 ## Features
 
 - **ACPProtocol**: Core ACP protocol implementation with JSON-RPC 2.0 support
-- **processChat**: Analyze chat content with tool invocation and whitelist enforcement
-- **Tool Factory**: Create tool definitions for ACP integration
+- **Tool Registration**: Register custom tools with descriptions and input schemas
 - **Tool Whitelist**: Built-in security model for controlling tool access
+- **Tool Execution**: Execute whitelisted tools with validation
 - **ES Module**: Pure ES modules, no build step required
 
 ## Installation
@@ -18,86 +18,162 @@ npm install acpreact
 
 ## Quick Start
 
-### Processing Chat Content
+### Creating an ACP Server with Custom Tools
 
 ```javascript
-import { processChat } from 'acpreact';
+import { ACPProtocol } from 'acpreact';
+
+const acp = new ACPProtocol();
 
-const chatContent = "[14:23] alice: Where is Taj Mahal?\n[14:24] bob: Main Street";
-const result = await processChat(chatContent, {
-  onToolCall: (toolName, args) => console.log('Tool:', toolName, args)
-});
-console.log(result.answer);
+// Register a custom tool
+acp.registerTool(
+  'weather',
+  'Get weather information for a location',
+  {
+    type: 'object',
+    properties: {
+      location: { type: 'string', description: 'City name' }
+    },
+    required: ['location']
+  },
+  async (params) => {
+    return {
+      location: params.location,
+      temperature: 72,
+      condition: 'sunny'
+    };
+  }
+);
+
+// Initialize protocol response
+const response = acp.createInitializeResponse();
+
+// Execute tool
+const result = await acp.callTool('weather', { location: 'San Francisco' });
+console.log(result);
 ```
 
-### Using ACPProtocol
+### Using System Instructions
+
+Pass a system instruction to the ACPProtocol constructor. The instruction will be included in the initialization response and communicated to opencode or kilo CLI:
 
 ```javascript
 import { ACPProtocol } from 'acpreact';
 
-const acp = new ACPProtocol();
+const instruction = 'You are a helpful weather assistant. Always provide temperature in Fahrenheit.';
+const acp = new ACPProtocol(instruction);
+
+// Register tools as usual
+acp.registerTool(
+  'weather',
+  'Get weather information for a location',
+  {
+    type: 'object',
+    properties: {
+      location: { type: 'string', description: 'City name' }
+    },
+    required: ['location']
+  },
+  async (params) => {
+    return {
+      location: params.location,
+      temperature: 72,
+      condition: 'sunny'
+    };
+  }
+);
+
+// The instruction is included in the initialization response
 const response = acp.createInitializeResponse();
-const result = await acp.callTool('simulative_retriever', {
-  query: 'Taj Mahal Main Street phone number'
-});
+console.log(response.result.instruction);
+// Output: "You are a helpful weather assistant. Always provide temperature in Fahrenheit."
 ```
 
-### Creating Tool Definitions
+## API
 
-```javascript
-import { createSimulativeRetriever } from 'acpreact';
+### ACPProtocol
 
-const tool = createSimulativeRetriever();
-// Use in your ACP setup
-```
+Main class for setting up ACP protocol communication.
 
-## API
+**Constructor:**
 
-### processChat(chatContent, options)
+- `new ACPProtocol(instruction)`: Initialize the protocol
+  - `instruction` (optional): String - system instruction to communicate to opencode or kilo CLI
 
-Process chat content with tool invocation and analysis.
+**Methods:**
 
-**Parameters:**
-- `chatContent`: String containing chat messages
-- `options`: Optional configuration object
-  - `onToolCall(toolName, args)`: Callback when a tool is invoked
-  - `systemPrompt`: Custom system prompt for analysis
+- `registerTool(name, description, inputSchema, handler)`: Register a custom tool
+  - `name`: String - tool identifier
+  - `description`: String - tool description
+  - `inputSchema`: Object - JSON Schema for tool inputs
+  - `handler`: Async function - receives params object, returns result
+  - Returns: Tool definition object
 
-**Returns:** Promise resolving to object with:
-- `answer`: Processed chat analysis
-- `toolCalls`: Array of tool invocations
-- `logs`: Tool execution log
-- `rejectedLogs`: Failed tool call attempts
+- `createInitializeResponse()`: Generate protocol initialization response
 
-**Example:**
-```javascript
-const result = await processChat(chatContent, {
-  onToolCall: (name, args) => console.log(`Called: ${name}`)
-});
-```
+- `createJsonRpcRequest(method, params)`: Create JSON-RPC request object
 
-### ACPProtocol
+- `createJsonRpcResponse(id, result)`: Create JSON-RPC response object
 
-Main protocol handler for ACP communication.
+- `createJsonRpcError(id, error)`: Create JSON-RPC error object
 
-**Methods:**
-- `createInitializeResponse()`: Generate protocol initialization response
-- `createJsonRpcRequest(method, params)`: Create JSON-RPC request
-- `createJsonRpcResponse(id, result)`: Create JSON-RPC response
-- `createJsonRpcError(id, error)`: Create JSON-RPC error
 - `validateToolCall(toolName)`: Check if tool is whitelisted
-- `callTool(toolName, params)`: Execute a whitelisted tool
+
+- `async callTool(toolName, params)`: Execute a registered tool
 
 **Properties:**
-- `toolWhitelist`: Set of allowed tool names
-- `toolCallLog`: Array of executed tool calls
+
+- `instruction`: String (optional) - system instruction communicated to opencode or kilo CLI
+- `toolWhitelist`: Set of registered tool names
+- `toolCallLog`: Array of executed tool calls with timestamps
 - `rejectedCallLog`: Array of rejected tool attempts
 
-### createSimulativeRetriever()
+## Example: Multiple Tools
+
+```javascript
+import { ACPProtocol } from 'acpreact';
 
-Factory function that returns a tool definition for simulative_retriever.
+const acp = new ACPProtocol();
 
-**Returns:** Tool object with name, description, and inputSchema
+// Register database tool
+acp.registerTool(
+  'query_database',
+  'Query the application database',
+  {
+    type: 'object',
+    properties: {
+      query: { type: 'string' }
+    },
+    required: ['query']
+  },
+  async (params) => {
+    // Your database logic here
+    return { data: [] };
+  }
+);
+
+// Register API tool
+acp.registerTool(
+  'call_api',
+  'Call an external API',
+  {
+    type: 'object',
+    properties: {
+      endpoint: { type: 'string' },
+      method: { type: 'string', enum: ['GET', 'POST'] }
+    },
+    required: ['endpoint', 'method']
+  },
+  async (params) => {
+    // Your API logic here
+    return { response: {} };
+  }
+);
+
+// Initialize and use
+const initResponse = acp.createInitializeResponse();
+console.log(initResponse.result.agentCapabilities);
+```
 
 ## License
 

package/core.js

@@ -1,12 +1,18 @@
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
 class ACPProtocol {
-  constructor() {
+  constructor(instruction) {
     this.messageId = 0;
-    this.toolWhitelist = new Set(['simulative_retriever']);
+    this.instruction = instruction;
+    this.toolWhitelist = new Set();
     this.toolCallLog = [];
     this.rejectedCallLog = [];
-    this.tools = {
-      simulative_retriever: this.simulativeRetriever.bind(this),
-    };
+    this.tools = {};
   }
 
   generateRequestId() {
@@ -41,71 +47,45 @@ class ACPProtocol {
     };
   }
 
-  createInitializeResponse() {
+  registerTool(name, description, inputSchema, handler) {
+    this.toolWhitelist.add(name);
+    this.tools[name] = handler;
     return {
-      jsonrpc: "2.0",
-      id: 0,
-      result: {
-        protocolVersion: "1.0",
-        serverInfo: {
-          name: "OpenCode ACP Server",
-          version: "1.0.0",
-        },
-        securityConfiguration: {
-          toolWhitelistEnabled: true,
-          allowedTools: Array.from(this.toolWhitelist),
-          rejectionBehavior: "strict",
-        },
-        agentCapabilities: [
-          {
-            type: "tool",
-            name: "simulative_retriever",
-            description: "Retrieve business information from a simulated database",
-            whitelisted: true,
-            inputSchema: {
-              type: "object",
-              properties: {
-                query: {
-                  type: "string",
-                  description: "The search query",
-                },
-              },
-              required: ["query"],
-            },
-            outputSchema: {
-              type: "object",
-              properties: {
-                success: { type: "boolean" },
-                result: { type: "string" },
-                details: { type: "string" },
-              },
-              required: ["success", "result", "details"],
-            },
-          },
-        ],
-      },
+      name,
+      description,
+      inputSchema,
     };
   }
 
-  simulativeRetriever(query) {
-    const lowerQuery = query.toLowerCase();
-    if (
-      (lowerQuery.includes("taj mahal") &&
-        lowerQuery.includes("main street")) &&
-      (lowerQuery.includes("phone") ||
-        lowerQuery.includes("number") ||
-        lowerQuery.includes("contact"))
-    ) {
-      return {
-        success: true,
-        result: "555-0142",
-        details: "Found phone number for Taj Mahal on Main Street: 555-0142",
-      };
+  createInitializeResponse() {
+    const agentCapabilities = Array.from(this.toolWhitelist).map(toolName => ({
+      type: "tool",
+      name: toolName,
+      whitelisted: true,
+    }));
+
+    const result = {
+      protocolVersion: "1.0",
+      serverInfo: {
+        name: "acpreact ACP Server",
+        version: "1.0.0",
+      },
+      securityConfiguration: {
+        toolWhitelistEnabled: true,
+        allowedTools: Array.from(this.toolWhitelist),
+        rejectionBehavior: "strict",
+      },
+      agentCapabilities,
+    };
+
+    if (this.instruction) {
+      result.instruction = this.instruction;
     }
+
     return {
-      success: false,
-      result: null,
-      details: `Information not found in database for query: "${query}"`,
+      jsonrpc: "2.0",
+      id: 0,
+      result,
     };
   }
 
@@ -133,12 +113,12 @@ class ACPProtocol {
     this.toolCallLog.push({
       timestamp: new Date().toISOString(),
       toolName,
-      query: params.query,
+      params,
       status: 'executing',
     });
 
     if (this.tools[toolName]) {
-      const result = this.tools[toolName](params.query);
+      const result = await this.tools[toolName](params);
       const lastLog = this.toolCallLog[this.toolCallLog.length - 1];
       lastLog.status = 'completed';
       lastLog.result = result;
@@ -146,46 +126,103 @@ class ACPProtocol {
     }
     throw new Error(`Unknown tool: ${toolName}`);
   }
-}
 
-function createSimulativeRetriever() {
-  return {
-    name: "simulative_retriever",
-    description: "Retrieve business information from a simulated database",
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: {
-          type: "string",
-          description: "The search query (e.g., 'Taj Mahal phone number')",
-        },
-      },
-      required: ["query"],
-    },
-  };
-}
+  async process(text, options = {}) {
+    const cli = options.cli || 'opencode';
+    const instruction = options.instruction || this.instruction || '';
+    
+    const toolsDesc = Array.from(this.toolWhitelist).map(name => {
+      const tool = this.tools[name];
+      return `- ${name}: Tool available`;
+    }).join('\n');
 
-async function processChat(chatContent, options = {}) {
-  const acp = new ACPProtocol();
-  const toolCalls = [];
-  const answer = chatContent;
+    const prompt = `${instruction}
 
-  const onToolCall = options.onToolCall || (() => {});
+Available tools:
+${toolsDesc}
 
-  if (options.onToolCall) {
-    toolCalls.push({
-      timestamp: new Date().toISOString(),
-      content: chatContent.substring(0, 100),
+Text to analyze:
+${text}
+
+Analyze the text and call appropriate tools using the ACP protocol. Respond with JSON-RPC tool calls.`;
+
+    return new Promise((resolve, reject) => {
+      let output = '';
+      let errorOutput = '';
+
+      const child = spawn(cli, ['--stdin'], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: process.cwd()
+      });
+
+      child.stdout.on('data', (data) => {
+        output += data.toString();
+      });
+
+      child.stderr.on('data', (data) => {
+        errorOutput += data.toString();
+      });
+
+      child.on('close', async (code) => {
+        if (code !== 0 && code !== null) {
+          reject(new Error(`CLI exited with code ${code}: ${errorOutput}`));
+          return;
+        }
+
+        try {
+          const toolCalls = this.parseToolCalls(output);
+          const results = [];
+          
+          for (const call of toolCalls) {
+            if (this.toolWhitelist.has(call.method)) {
+              const result = await this.callTool(call.method, call.params);
+              results.push({ tool: call.method, result });
+            }
+          }
+          
+          resolve({
+            text: output,
+            toolCalls: results,
+            logs: this.toolCallLog
+          });
+        } catch (e) {
+          resolve({
+            text: output,
+            error: e.message,
+            logs: this.toolCallLog
+          });
+        }
+      });
+
+      child.on('error', (error) => {
+        reject(new Error(`Failed to spawn ${cli}: ${error.message}`));
+      });
+
+      child.stdin.write(prompt);
+      child.stdin.end();
     });
-    onToolCall('analyze', { content: chatContent });
   }
 
-  return {
-    answer,
-    toolCalls,
-    logs: acp.toolCallLog,
-    rejectedLogs: acp.rejectedCallLog,
-  };
+  parseToolCalls(output) {
+    const calls = [];
+    const lines = output.split('\n');
+    
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      
+      try {
+        const json = JSON.parse(trimmed);
+        if (json.jsonrpc === '2.0' && json.method && json.params) {
+          calls.push({ method: json.method, params: json.params });
+        }
+      } catch (e) {
+        // Not JSON, skip
+      }
+    }
+    
+    return calls;
+  }
 }
 
-export { ACPProtocol, createSimulativeRetriever, processChat };
+export { ACPProtocol };

package/index.js

@@ -1,25 +1,28 @@
-import { ACPProtocol, createSimulativeRetriever, processChat } from './core.js';
+import { ACPProtocol } from './core.js';
 
-export { ACPProtocol, createSimulativeRetriever, processChat };
+export { ACPProtocol };
 
 /*
- * ACP SDK Usage Examples
+ * acpreact - ACP SDK for registering tools
  *
  * Basic usage:
- *   import { ACPProtocol, createSimulativeRetriever, processChat } from 'acpreact';
+ *   import { ACPProtocol } from 'acpreact';
  *
- * Create and use ACP Protocol:
+ * Create ACP Protocol instance:
  *   const acp = new ACPProtocol();
- *   const response = acp.createInitializeResponse();
- *   const result = await acp.callTool('simulative_retriever', { query: 'test' });
- *
- * Create tool definition:
- *   const tool = createSimulativeRetriever();
  *
- * Process chat content:
- *   const chatContent = "[14:23] alice: Where is Taj Mahal?\n[14:24] bob: Main Street";
- *   const result = await processChat(chatContent, {
- *     onToolCall: (toolName, args) => console.log(toolName, args)
+ * Register custom tools:
+ *   acp.registerTool('my_tool', 'Tool description', {
+ *     type: 'object',
+ *     properties: { query: { type: 'string' } },
+ *     required: ['query']
+ *   }, async (params) => {
+ *     return { result: 'processed' };
  *   });
- *   console.log(result.answer);
+ *
+ * Initialize protocol:
+ *   const response = acp.createInitializeResponse();
+ *
+ * Execute tool:
+ *   const result = await acp.callTool('my_tool', { query: 'test' });
  */

package/package.json

@@ -1,15 +1,21 @@
 {
   "name": "acpreact",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "type": "module",
   "main": "index.js",
   "description": "ACP SDK for monitoring and reacting to chat conversations",
-  "keywords": ["acp", "protocol", "chat", "monitoring"],
+  "keywords": [
+    "acp",
+    "protocol",
+    "chat",
+    "monitoring"
+  ],
   "author": "",
   "license": "ISC",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.74.0",
     "@opencode-ai/plugin": "^1.2.5",
-    "@opencode-ai/sdk": "^1.2.5"
+    "@opencode-ai/sdk": "^1.2.5",
+    "@kilocode/cli": "^1.0.0"
   }
 }