loom-agent 1.2.0

package/src/acp/acp-server.js

@@ -0,0 +1,287 @@
+// Agent Client Protocol (ACP) server — lets ACP-compatible editors (Zed,
+// JetBrains, Avante.nvim, CodeCompanion.nvim, ...) drive Loom as a subprocess.
+//
+// Transport: JSON-RPC 2.0 messages, one per line (newline-delimited JSON) over
+// stdio. The editor sends requests on stdin; Loom answers on stdout and queues
+// agent events that the client retrieves with fetchAgentEvent.
+//
+// Implemented methods (subset of the ACP spec):
+//   initialize, connect, storeMessage, sendChatRequest, fetchAgentEvent,
+//   cancelCurrentTask, updateAgentConfig, changeDefaultMode, enableToolUse,
+//   disposeTool
+//
+// Run with: loom acp   (or:  bun src/acp/acp-server.js)
+const readline = require('readline');
+const os = require('os');
+const path = require('path');
+const { Session, isAbortError } = require('../core/session');
+const { getToolDefinitions } = require('../tools');
+const { loadConfig, saveConfig } = require('../config/settings');
+
+const ACP_METHODS = new Set([
+  'initialize',
+  'connect',
+  'storeMessage',
+  'sendChatRequest',
+  'fetchAgentEvent',
+  'cancelCurrentTask',
+  'updateAgentConfig',
+  'changeDefaultMode',
+  'enableToolUse',
+  'disposeTool',
+]);
+
+/** @typedef {Object} AcpTask
+ *  @property {Session} session
+ *  @property {boolean} active
+ *  @property {Array<object>} events
+ *  @property {string} mode
+ */
+
+class AcpServer {
+  /**
+   * @param {object} [opts]
+   * @param {NodeJS.ReadableStream|any} [opts.input]
+   * @param {NodeJS.WritableStream|any} [opts.output]
+   */
+  constructor(opts = {}) {
+    this.input = opts.input || process.stdin;
+    this.output = opts.output || process.stdout;
+    /** @type {Map<string, AcpTask>} */
+    this.tasks = new Map();
+    this.rl = null;
+  }
+
+  start() {
+    this.rl = readline.createInterface({ input: this.input, terminal: false });
+    this.rl.on('line', (line) => {
+      const trimmed = String(line).trim();
+      if (!trimmed) return;
+      let req;
+      try { req = JSON.parse(trimmed); } catch { return; }
+      this.handleRequest(req).catch((e) => {
+        if (req && req.id != null) this.reply(req.id, null, { code: -32603, message: e && e.message ? e.message : String(e) });
+      });
+    });
+  }
+
+  /** @param {object} req */
+  async handleRequest(req) {
+    if (!req || typeof req.method !== 'string') return;
+    const method = req.method;
+    const params = req.params || {};
+    const id = req.id != null ? req.id : null;
+    if (!ACP_METHODS.has(method)) {
+      if (id != null) this.reply(id, null, { code: -32601, message: 'Method not found: ' + method });
+      return;
+    }
+    if (id == null) {
+      // Notification — methods that expect a response still work; ignore result.
+      try { await this[method](params); } catch {}
+      return;
+    }
+    try {
+      const result = await this[method](params);
+      this.reply(id, result === undefined ? null : result, null);
+    } catch (e) {
+      this.reply(id, null, { code: -32603, message: e && e.message ? e.message : String(e) });
+    }
+  }
+
+  /** @param {number|string|null} id
+   *  @param {*} result
+   *  @param {{code:number, message:string}|null} error */
+  reply(id, result, error) {
+    const msg = { jsonrpc: '2.0', id };
+    if (error) msg.error = error;
+    else msg.result = result !== undefined ? result : null;
+    this.write(msg);
+  }
+
+  /** @param {object} obj */
+  write(obj) {
+    try { this.output.write(JSON.stringify(obj) + '\n'); } catch {}
+  }
+
+  // ── ACP methods ──
+
+  initialize() {
+    const defs = getToolDefinitions('build');
+    return {
+      protocolVersion: 1,
+      capabilities: { openai: true, customInstructions: true },
+      toolSchemas: defs.map((d) => ({
+        type: 'function',
+        function: {
+          name: d.name,
+          description: d.description,
+          parameters: d.input_schema || { type: 'object', properties: {} },
+        },
+      })),
+      agentConfig: {
+        builtInTools: defs.map((d) => d.name),
+        customInstructions: null,
+        includeAgentContext: false,
+      },
+    };
+  }
+
+  /**
+   * @param {{taskId?: string, agentConfig?: object}} params
+   */
+  connect(params) {
+    const taskId = params.taskId || 'task-' + Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+    const session = new Session();
+    const agentConfig = params.agentConfig || {};
+    if (agentConfig.mode === 'plan' || agentConfig.mode === 'chat' || agentConfig.mode === 'build') {
+      session.setMode(agentConfig.mode);
+    }
+    if (typeof agentConfig.instructions === 'string' && agentConfig.instructions.trim()) {
+      session._agentBlock = '\n\n[ACP session instructions]\n' + agentConfig.instructions.trim() + '\n';
+    }
+    /** @type {AcpTask} */
+    const task = { session, active: false, events: [], mode: session.mode };
+    this.tasks.set(taskId, task);
+    this.pushEvent(task, 'session.updated', { type: 'created' });
+    return { taskId };
+  }
+
+  /**
+   * @param {{taskId: string, message: object}} params
+   */
+  storeMessage(params) {
+    const task = this.getTask(params.taskId);
+    const msg = params.message || {};
+    task.session.addMessage({ role: msg.role === 'assistant' ? 'assistant' : 'user', content: String(msg.content || '') });
+    this.pushEvent(task, 'session.updated', { type: 'expanded' });
+    return null;
+  }
+
+  /**
+   * @param {{taskId: string, message: {content?: string}}} params
+   */
+  async sendChatRequest(params) {
+    const task = this.getTask(params.taskId);
+    if (task.active) throw new Error('Task already has an active request; wait for it to complete or cancel it.');
+    const text = String((params.message && params.message.content) || '');
+    if (!text.trim()) throw new Error('Message content is empty.');
+    const requestId = 'req-' + Date.now().toString(36) + '-' + Math.floor(Math.random() * 1e6).toString(36);
+    const messageId = 'msg-' + Date.now().toString(36);
+    task.active = true;
+    this.pushEvent(task, 'session.updated', { type: 'expanded' });
+    (() => {
+      task.session.sendUserMessage(text, {
+        onDelta: (t) => this.pushEvent(task, 'agent.message', { messageId, content: { type: 'text', content: t } }),
+        onReasoning: (t) => this.pushEvent(task, 'agent.message', { messageId: messageId + '-r', content: { type: 'reasoning', content: t } }),
+        onTool: (toolName, input) => this.pushEvent(task, 'tool.use', { toolName, id: 'tool-' + Date.now().toString(36), input }),
+        onToolResult: (toolName, out, input) =>
+          this.pushEvent(task, 'tool.result', { toolName, input, result: out && out.result != null ? out.result : (out && out.error) }),
+      }).then((resp) => {
+        this.pushEvent(task, 'session.updated', { type: 'expanded' });
+        if (resp.interrupted) {
+          this.pushEvent(task, 'request.error', { requestId, message: '(interrupted)' });
+        } else if (resp.type === 'error') {
+          this.pushEvent(task, 'request.error', { requestId, message: String(resp.content || '') });
+        } else {
+          this.pushEvent(task, 'agent.message.completed', { messageId });
+          this.pushEvent(task, 'request.completed', { requestId, response: { type: 'text', text: String(resp.content || '') } });
+        }
+      }).catch((e) => {
+        this.pushEvent(task, 'session.updated', { type: 'expanded' });
+        if (isAbortError(e)) {
+          this.pushEvent(task, 'request.error', { requestId, message: '(interrupted)' });
+        } else {
+          this.pushEvent(task, 'request.error', { requestId, message: e && e.message ? e.message : String(e) });
+        }
+      }).finally(() => {
+        task.active = false;
+      });
+    })();
+    return { requestId };
+  }
+
+  /**
+   * @param {{taskId: string, cursor?: number}} params
+   */
+  fetchAgentEvent(params) {
+    const task = this.getTask(params.taskId);
+    const cursor = Number(params.cursor || 0);
+    const events = task.events.slice(cursor);
+    return { events, cursor: cursor + events.length };
+  }
+
+  /**
+   * @param {{taskId: string}} params
+   */
+  cancelCurrentTask(params) {
+    const task = this.getTask(params.taskId);
+    try { task.session.interrupt(); } catch {}
+    return null;
+  }
+
+  /**
+   * @param {{taskId: string, agentConfig?: object}} params
+   */
+  updateAgentConfig(params) {
+    const task = this.getTask(params.taskId);
+    const agentConfig = params.agentConfig || {};
+    if (typeof agentConfig.instructions === 'string' && agentConfig.instructions.trim()) {
+      task.session._agentBlock = '\n\n[ACP session instructions]\n' + agentConfig.instructions.trim() + '\n';
+    }
+    return null;
+  }
+
+  /**
+   * @param {{taskId: string, mode?: string}} params
+   */
+  changeDefaultMode(params) {
+    const task = this.getTask(params.taskId);
+    if (params.mode === 'plan' || params.mode === 'chat' || params.mode === 'build') {
+      task.session.setMode(params.mode);
+      task.mode = params.mode;
+    }
+    return null;
+  }
+
+  enableToolUse() {
+    // All built-in tools + MCP tools are enabled by default; nothing to gate.
+    return null;
+  }
+
+  disposeTool() {
+    return null;
+  }
+
+  /** @param {string} taskId
+   * @returns {AcpTask} */
+  getTask(taskId) {
+    const task = this.tasks.get(String(taskId));
+    if (!task) throw new Error('Unknown task: ' + taskId);
+    return task;
+  }
+
+  /** @param {AcpTask} task
+   *  @param {string} event
+   *  @param {object} payload */
+  pushEvent(task, event, payload) {
+    const item = { id: Date.now().toString(36) + Math.random().toString(36).slice(2, 8), event, ...payload };
+    task.events.push(item);
+    return item;
+  }
+}
+
+/** Print a tiny readiness line to stderr (never corrupts the stdio protocol). */
+function announce() {
+  const c = loadConfig();
+  const loc = process.env.LOOM_CONFIG_DIR || path.join(os.homedir(), '.loom', 'config.json');
+  process.stderr.write(`[loom acp] started — provider: ${c.provider}, config: ${loc}\n`);
+}
+
+function main() {
+  announce();
+  const server = new AcpServer();
+  server.start();
+  process.stdin.resume();
+}
+
+module.exports = { AcpServer, main };

package/src/config/provider-cmd.js

@@ -0,0 +1,37 @@
+const { loadConfig, saveConfig } = require('./settings');
+const { loadRegistry, envNamesFor } = require('../providers/registry');
+
+function connect(provider, apiKey) {
+  const valid = ['anthropic', 'openai', 'nvidia', 'google', 'local'];
+  const reg = loadRegistry() || {};
+  if (!valid.includes(provider) && !reg[provider]) {
+    throw new Error(`Unknown provider: ${provider}. Run /providers to list every supported provider.`);
+  }
+  const config = loadConfig();
+  config.provider = provider;
+  config.apiKeys = config.apiKeys || {};
+  if (apiKey) config.apiKeys[provider] = apiKey;
+  saveConfig(config);
+  return `Connected to ${provider}.`;
+}
+
+function disconnect() {
+  const config = loadConfig();
+  const old = config.provider;
+  config.provider = '';
+  config.apiKeys = config.apiKeys || {};
+  delete config.apiKeys[old];
+  saveConfig(config);
+  return `Disconnected from ${old}.`;
+}
+
+function status() {
+  const config = loadConfig();
+  return {
+    provider: config.provider,
+    model: config.model?.[config.provider] || 'default',
+    hasKey: !!(config.apiKeys?.[config.provider] || (envNamesFor(config.provider) || []).some(n => !!process.env[n]))
+  };
+}
+
+module.exports = { connect, disconnect, status };

package/src/config/settings.js

@@ -0,0 +1,164 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const LOOM_DIR = path.join(os.homedir(), '.loom');
+const CONFIG_FILE = path.join(LOOM_DIR, 'config.json');
+const GLOBAL_LOOM_MD = path.join(LOOM_DIR, 'LOOM.md');
+
+// Re-evaluated on every call so tests/CI can point config elsewhere with
+// LOOM_CONFIG_DIR; the exported LOOM_DIR/CONFIG_FILE constants keep the
+// default for display purposes.
+function loomDir() {
+  return process.env.LOOM_CONFIG_DIR || LOOM_DIR;
+}
+
+function configFile() {
+  return path.join(loomDir(), 'config.json');
+}
+
+const DEFAULTS = {
+  provider: 'anthropic',
+  model: {
+    anthropic: 'claude-sonnet-4-20250514',
+    openai: 'gpt-5-fast',
+    nvidia: 'meta/llama-3.1-8b-instruct',
+    google: 'gemini-2.5-flash',
+    openrouter: 'anthropic/claude-sonnet-4',
+    tokenrouter: 'moonshotai/kimi-k3-free',
+    local: 'llama3.2',
+  },
+  maxTokens: 16384,
+  temperature: 0.3,
+  compactThreshold: 0.75,
+  budgetLevel: 'auto', // free | cheap | best | auto (explicit picks)
+  apiKeys: {},
+  customEndpoints: {},
+  recentModels: [],
+  skillDisabled: [],
+  // OpenCode-style formatters / LSP. false = disabled (default). true = enable
+  // all built-ins. object = built-ins + per-id overrides/customs.
+  formatter: false,
+  lsp: false,
+  baseUrls: {
+    anthropic: 'https://api.anthropic.com',
+    openai: 'https://api.openai.com/v1',
+    nvidia: 'https://integrate.api.nvidia.com/v1',
+    google: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+    openrouter: 'https://openrouter.ai/api/v1',
+    tokenrouter: 'https://api.tokenrouter.com/v1',
+    local: 'http://localhost:11434/v1',
+  },
+};
+
+function ensureLoomDir() {
+  const dir = loomDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function loadConfig() {
+  ensureLoomDir();
+  const file = configFile();
+  if (fs.existsSync(file)) {
+    try { fs.chmodSync(file, 0o600); } catch {}
+    try {
+      const raw = fs.readFileSync(file, 'utf8');
+      return { ...DEFAULTS, ...JSON.parse(raw) };
+    } catch {
+      return { ...DEFAULTS };
+    }
+  }
+  return { ...DEFAULTS };
+}
+
+function saveConfig(config) {
+  ensureLoomDir();
+  const file = configFile();
+  fs.writeFileSync(file, JSON.stringify(config, null, 2));
+  try { fs.chmodSync(file, 0o600); } catch {}
+}
+
+function getApiKey(provider) {
+  const { envNamesFor } = require('../providers/registry');
+  const envNames = envNamesFor(provider) || [];
+  for (const key of envNames) {
+    if (process.env[key]) return process.env[key];
+  }
+
+  const config = loadConfig();
+  return config.apiKeys?.[provider] || null;
+}
+
+function setApiKey(provider, key) {
+  const config = loadConfig();
+  config.apiKeys = config.apiKeys || {};
+  config.apiKeys[provider] = key;
+  saveConfig(config);
+}
+
+function resolveApiKey(provider) {
+  const key = getApiKey(provider);
+  if (!key) {
+    throw new Error(
+      `No API key found for ${provider}. Set the env variable or run: loom connect ${provider} <key>`
+    );
+  }
+  return key;
+}
+
+function getBaseUrl(provider) {
+  const envMap = {
+    anthropic: ['ANTHROPIC_BASE_URL'],
+    openai: ['OPENAI_BASE_URL'],
+    nvidia: ['NVIDIA_BASE_URL'],
+    google: ['GOOGLE_BASE_URL'],
+    openrouter: ['OPENROUTER_BASE_URL'],
+    tokenrouter: ['TOKENROUTER_BASE_URL'],
+  };
+  for (const env of (envMap[provider] || [])) {
+    if (process.env[env]) return process.env[env];
+  }
+  const cfg = loadConfig();
+  return cfg.baseUrls?.[provider] || cfg.customEndpoints?.[provider] || DEFAULTS.baseUrls?.[provider] || null;
+}
+
+function setBaseUrl(provider, url) {
+  const config = loadConfig();
+  config.baseUrls = config.baseUrls || {};
+  config.baseUrls[provider] = url;
+  saveConfig(config);
+}
+
+// Remember which provider+model was used, most recent first (deduped, capped).
+function recordModelUse(provider, modelId) {
+  if (!provider || !modelId) return;
+  const config = loadConfig();
+  const list = (config.recentModels || []).filter(r => !(r.provider === provider && r.model === modelId));
+  list.unshift({ provider, model: modelId, at: Date.now() });
+  config.recentModels = list.slice(0, 8);
+  saveConfig(config);
+}
+
+function getRecentModels() {
+  const cfg = loadConfig();
+  return (cfg.recentModels || []).slice(0, 8);
+}
+
+// Whether a usable key exists for a provider (or it's a keyless local backend).
+function hasApiKey(provider) {
+  if (provider === 'local') return true;
+  const { envNamesFor } = require('../providers/registry');
+  const cfg = loadConfig();
+  if (cfg.apiKeys?.[provider]) return true;
+  return (envNamesFor(provider) || []).some(n => !!process.env[n]);
+}
+
+module.exports = {
+  LOOM_DIR, CONFIG_FILE, GLOBAL_LOOM_MD, DEFAULTS,
+  loadConfig, saveConfig,
+  getApiKey, setApiKey, resolveApiKey,
+  ensureLoomDir, getBaseUrl, setBaseUrl,
+  recordModelUse, getRecentModels, hasApiKey
+};