chainlesschain 0.45.70 → 0.45.74

package/src/lib/hashline.js

@@ -0,0 +1,208 @@
+/**
+ * Hashline — content-hash anchored line editing (v5.0.2.9)
+ *
+ * Inspired by oh-my-openagent's "Hashline" design: rather than referring to
+ * code by line number (brittle across concurrent edits) or by exact string
+ * match (brittle across whitespace drift), each line is tagged with a short
+ * content hash. Edits reference the hash and are rejected if the current
+ * file contents no longer match — preventing stale-line corruption.
+ *
+ * Pure functions only — zero side effects, fully testable.
+ *
+ * Tag format: `<6-char base64url>| <line content>`
+ *   Empty / whitespace-only lines use `______` (6 underscores).
+ *
+ * Hash is computed over `line.trim()`, making it insensitive to leading /
+ * trailing whitespace — rebust against auto-formatters and indentation drift.
+ */
+
+import crypto from "crypto";
+
+const HASH_LENGTH = 6;
+const EMPTY_HASH = "______";
+const SEPARATOR = "| ";
+
+/**
+ * Compute the stable hash for a single line.
+ * Whitespace-insensitive: `.trim()` is applied before hashing.
+ *
+ * @param {string} line
+ * @returns {string} 6-char base64url hash, or "______" for empty/whitespace
+ */
+export function hashLine(line) {
+  if (typeof line !== "string") return EMPTY_HASH;
+  const trimmed = line.trim();
+  if (trimmed.length === 0) return EMPTY_HASH;
+  return crypto
+    .createHash("sha256")
+    .update(trimmed, "utf8")
+    .digest("base64url")
+    .slice(0, HASH_LENGTH);
+}
+
+/**
+ * Split content into lines, preserving line-ending style for round-trips.
+ * Detects CRLF vs LF; mixed endings fall back to LF.
+ *
+ * @param {string} content
+ * @returns {{ lines: string[], eol: "\r\n" | "\n" }}
+ */
+export function splitLines(content) {
+  if (typeof content !== "string") return { lines: [], eol: "\n" };
+  const hasCRLF = content.includes("\r\n");
+  const hasLF = content.includes("\n");
+  // Only treat as CRLF if no bare LFs appear outside CRLF pairs
+  if (hasCRLF) {
+    // Count bare \n (\n not preceded by \r)
+    const bareLFs = (content.match(/(^|[^\r])\n/g) || []).length;
+    const crlfs = (content.match(/\r\n/g) || []).length;
+    const eol = bareLFs === 0 || bareLFs < crlfs / 2 ? "\r\n" : "\n";
+    return { lines: content.split(/\r?\n/), eol };
+  }
+  return { lines: hasLF ? content.split("\n") : [content], eol: "\n" };
+}
+
+/**
+ * Annotate content: prepend each line with `<hash>| `.
+ *
+ * @param {string} content
+ * @returns {string} annotated content
+ */
+export function annotateLines(content) {
+  const { lines, eol } = splitLines(content);
+  return lines.map((line) => `${hashLine(line)}${SEPARATOR}${line}`).join(eol);
+}
+
+/**
+ * Find all lines whose hash matches the anchor.
+ *
+ * @param {string} content
+ * @param {string} anchorHash
+ * @returns {Array<{ index: number, lineNumber: number, content: string }>}
+ */
+export function findByHash(content, anchorHash) {
+  if (!anchorHash || typeof anchorHash !== "string") return [];
+  const { lines } = splitLines(content);
+  const matches = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (hashLine(lines[i]) === anchorHash) {
+      matches.push({
+        index: i,
+        lineNumber: i + 1, // 1-based for human-friendly display
+        content: lines[i],
+      });
+    }
+  }
+  return matches;
+}
+
+/**
+ * Verify the current content of a line matches both the anchor hash and the
+ * expected trimmed content. Used as a second-layer check to defend against
+ * hash collisions.
+ *
+ * @param {string} currentLine
+ * @param {string} anchorHash
+ * @param {string} expectedLine - Expected content (compared trimmed)
+ * @returns {boolean}
+ */
+export function verifyLine(currentLine, anchorHash, expectedLine) {
+  if (hashLine(currentLine) !== anchorHash) return false;
+  if (typeof expectedLine !== "string") return true;
+  return currentLine.trim() === expectedLine.trim();
+}
+
+/**
+ * Replace a single line at the given anchor hash. Returns either the new
+ * content or a structured error.
+ *
+ * Error shapes (not thrown — returned so the agent loop can present them):
+ *   { error: "hash_mismatch",    ... }   — anchor doesn't match any line
+ *   { error: "ambiguous_anchor", ... }   — anchor matches multiple lines
+ *   { error: "content_mismatch", ... }   — hash matches but expected_line differs
+ *
+ * @param {string} content - Full file content
+ * @param {object} opts
+ * @param {string} opts.anchorHash
+ * @param {string} opts.expectedLine
+ * @param {string} opts.newLine
+ * @param {number} [opts.contextLines=3] - Lines of context for error snippets
+ * @returns {{ success: true, content: string, lineNumber: number } | { success: false, error: string, [key: string]: any }}
+ */
+export function replaceByHash(content, opts) {
+  const { anchorHash, expectedLine, newLine, contextLines = 3 } = opts;
+  const { lines, eol } = splitLines(content);
+  const matches = findByHash(content, anchorHash);
+
+  if (matches.length === 0) {
+    return {
+      success: false,
+      error: "hash_mismatch",
+      message: `No line matches anchor hash "${anchorHash}"`,
+      hint: "Re-read the file with hashed:true to get current hashes",
+    };
+  }
+
+  if (matches.length > 1) {
+    return {
+      success: false,
+      error: "ambiguous_anchor",
+      message: `Anchor hash "${anchorHash}" matches ${matches.length} lines`,
+      matches: matches.map((m) => ({
+        lineNumber: m.lineNumber,
+        content: m.content,
+      })),
+      hint: "Use edit_file with a unique old_string or refine the anchor",
+    };
+  }
+
+  const match = matches[0];
+  if (
+    typeof expectedLine === "string" &&
+    match.content.trim() !== expectedLine.trim()
+  ) {
+    return {
+      success: false,
+      error: "content_mismatch",
+      message: `Line ${match.lineNumber} has hash ${anchorHash} but content differs from expected_line`,
+      current: match.content,
+      expected: expectedLine,
+      hint: "Re-read the file to see current content",
+    };
+  }
+
+  // Replace — preserve leading whitespace from original line if new_line has none
+  const newLines = [...lines];
+  newLines[match.index] = newLine;
+  return {
+    success: true,
+    content: newLines.join(eol),
+    lineNumber: match.lineNumber,
+    previousContent: match.content,
+  };
+}
+
+/**
+ * Produce a small snippet of context around a given line index for error
+ * messages. Uses annotated form so the agent can retry with fresh hashes.
+ *
+ * @param {string} content
+ * @param {number} lineIndex - 0-based
+ * @param {number} [contextLines=3]
+ * @returns {string}
+ */
+export function snippetAround(content, lineIndex, contextLines = 3) {
+  const { lines, eol } = splitLines(content);
+  const start = Math.max(0, lineIndex - contextLines);
+  const end = Math.min(lines.length, lineIndex + contextLines + 1);
+  const slice = lines
+    .slice(start, end)
+    .map((line, i) => `${hashLine(line)}${SEPARATOR}${line}`);
+  return slice.join(eol);
+}
+
+export const _internals = {
+  HASH_LENGTH,
+  EMPTY_HASH,
+  SEPARATOR,
+};

package/src/lib/jsonl-session-store.js

@@ -1,3 +1,14 @@
+/**
+ * @deprecated — canonical implementation lives in
+ * `../harness/jsonl-session-store.js` as of the CLI Runtime Convergence
+ * roadmap. This file is retained as a re-export shim for backwards
+ * compatibility and will be removed once all external consumers have
+ * migrated.
+ *
+ * Please import from `packages/cli/src/harness/jsonl-session-store.js`
+ * in new code.
+ */
+
 export {
   appendEvent,
   startSession,

package/src/lib/mcp-client.js

@@ -1,413 +1,15 @@
 /**
- * Lightweight MCP (Model Context Protocol) client.
- * Implements JSON-RPC 2.0 over stdio transport without external SDK dependency.
- */
-
-import { spawn } from "child_process";
-import { EventEmitter } from "events";
-
-/**
- * MCP Server connection states.
- */
-export const ServerState = {
-  DISCONNECTED: "disconnected",
-  CONNECTING: "connecting",
-  CONNECTED: "connected",
-  ERROR: "error",
-};
-
-/**
- * MCP Client — manages connections to MCP servers.
- */
-export class MCPClient extends EventEmitter {
-  constructor() {
-    super();
-    this.servers = new Map(); // name → { process, state, tools, resources, config }
-    this._nextId = 1;
-  }
-
-  /**
-   * Connect to an MCP server via stdio transport.
-   * @param {string} name - Server name
-   * @param {object} config - { command, args?, env? }
-   */
-  async connect(name, config) {
-    if (this.servers.has(name)) {
-      throw new Error(`Server "${name}" already connected`);
-    }
-
-    const entry = {
-      config,
-      state: ServerState.CONNECTING,
-      process: null,
-      tools: [],
-      resources: [],
-      prompts: [],
-      _pending: new Map(),
-      _buffer: "",
-    };
-
-    this.servers.set(name, entry);
-
-    try {
-      const proc = spawn(config.command, config.args || [], {
-        stdio: ["pipe", "pipe", "pipe"],
-        env: { ...process.env, ...(config.env || {}) },
-      });
-
-      entry.process = proc;
-
-      proc.stdout.on("data", (data) => {
-        this._handleData(name, data.toString("utf8"));
-      });
-
-      proc.stderr.on("data", (data) => {
-        this.emit("server-error", { name, error: data.toString("utf8") });
-      });
-
-      proc.on("close", (code) => {
-        entry.state = ServerState.DISCONNECTED;
-        this.emit("server-disconnected", { name, code });
-      });
-
-      proc.on("error", (err) => {
-        entry.state = ServerState.ERROR;
-        this.emit("server-error", { name, error: err.message });
-      });
-
-      // Initialize MCP protocol
-      const initResult = await this._sendRequest(name, "initialize", {
-        protocolVersion: "2024-11-05",
-        capabilities: { tools: {}, resources: {} },
-        clientInfo: { name: "chainlesschain-cli", version: "0.37.9" },
-      });
-
-      // Send initialized notification
-      this._sendNotification(name, "notifications/initialized", {});
-
-      entry.state = ServerState.CONNECTED;
-      entry.serverInfo = initResult?.serverInfo || {};
-      entry.capabilities = initResult?.capabilities || {};
-
-      // Fetch available tools
-      try {
-        const toolsResult = await this._sendRequest(name, "tools/list", {});
-        entry.tools = toolsResult?.tools || [];
-      } catch {
-        // Server may not support tools
-      }
-
-      // Fetch available resources
-      try {
-        const resourcesResult = await this._sendRequest(
-          name,
-          "resources/list",
-          {},
-        );
-        entry.resources = resourcesResult?.resources || [];
-      } catch {
-        // Server may not support resources
-      }
-
-      this.emit("server-connected", { name, tools: entry.tools.length });
-      return {
-        name,
-        state: entry.state,
-        tools: entry.tools,
-        resources: entry.resources,
-        serverInfo: entry.serverInfo,
-      };
-    } catch (err) {
-      entry.state = ServerState.ERROR;
-      this.servers.delete(name);
-      throw err;
-    }
-  }
-
-  /**
-   * Disconnect from an MCP server.
-   */
-  async disconnect(name) {
-    const entry = this.servers.get(name);
-    if (!entry) return false;
-
-    if (entry.process) {
-      entry.process.kill();
-    }
-
-    entry.state = ServerState.DISCONNECTED;
-    this.servers.delete(name);
-    return true;
-  }
-
-  /**
-   * Disconnect from all servers.
-   */
-  async disconnectAll() {
-    const names = [...this.servers.keys()];
-    for (const name of names) {
-      await this.disconnect(name);
-    }
-  }
-
-  /**
-   * List all connected servers.
-   */
-  listServers() {
-    const result = [];
-    for (const [name, entry] of this.servers) {
-      result.push({
-        name,
-        state: entry.state,
-        tools: entry.tools.length,
-        resources: entry.resources.length,
-        serverInfo: entry.serverInfo || {},
-      });
-    }
-    return result;
-  }
-
-  /**
-   * List tools from a specific server or all servers.
-   */
-  listTools(serverName) {
-    if (serverName) {
-      const entry = this.servers.get(serverName);
-      if (!entry) throw new Error(`Server "${serverName}" not found`);
-      return entry.tools.map((t) => ({ ...t, server: serverName }));
-    }
-
-    const allTools = [];
-    for (const [name, entry] of this.servers) {
-      for (const tool of entry.tools) {
-        allTools.push({ ...tool, server: name });
-      }
-    }
-    return allTools;
-  }
-
-  /**
-   * Call a tool on a specific server.
-   * @param {string} serverName - Server name
-   * @param {string} toolName - Tool name
-   * @param {object} args - Tool arguments
-   */
-  async callTool(serverName, toolName, args = {}) {
-    const entry = this.servers.get(serverName);
-    if (!entry) throw new Error(`Server "${serverName}" not found`);
-    if (entry.state !== ServerState.CONNECTED) {
-      throw new Error(`Server "${serverName}" is not connected`);
-    }
-
-    const result = await this._sendRequest(serverName, "tools/call", {
-      name: toolName,
-      arguments: args,
-    });
-
-    return result;
-  }
-
-  /**
-   * Read a resource from a server.
-   */
-  async readResource(serverName, uri) {
-    const entry = this.servers.get(serverName);
-    if (!entry) throw new Error(`Server "${serverName}" not found`);
-
-    const result = await this._sendRequest(serverName, "resources/read", {
-      uri,
-    });
-    return result;
-  }
-
-  // ─── Internal JSON-RPC transport ──────────────────────────────
-
-  _sendRequest(serverName, method, params) {
-    return new Promise((resolve, reject) => {
-      const entry = this.servers.get(serverName);
-      if (!entry || !entry.process) {
-        return reject(new Error("Server not available"));
-      }
-
-      const id = this._nextId++;
-      const message = JSON.stringify({
-        jsonrpc: "2.0",
-        id,
-        method,
-        params,
-      });
-
-      entry._pending.set(id, { resolve, reject });
-
-      // Set timeout
-      const timeout = setTimeout(() => {
-        entry._pending.delete(id);
-        reject(new Error(`Request timeout: ${method}`));
-      }, 30000);
-
-      entry._pending.get(id).timeout = timeout;
-
-      try {
-        entry.process.stdin.write(message + "\n");
-      } catch (err) {
-        clearTimeout(timeout);
-        entry._pending.delete(id);
-        reject(err);
-      }
-    });
-  }
-
-  _sendNotification(serverName, method, params) {
-    const entry = this.servers.get(serverName);
-    if (!entry || !entry.process) return;
-
-    const message = JSON.stringify({
-      jsonrpc: "2.0",
-      method,
-      params,
-    });
-
-    try {
-      entry.process.stdin.write(message + "\n");
-    } catch {
-      // Ignore notification errors
-    }
-  }
-
-  _handleData(serverName, data) {
-    const entry = this.servers.get(serverName);
-    if (!entry) return;
-
-    entry._buffer += data;
-
-    // Process complete JSON lines
-    const lines = entry._buffer.split("\n");
-    entry._buffer = lines.pop() || "";
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-
-      try {
-        const msg = JSON.parse(trimmed);
-        this._handleMessage(serverName, msg);
-      } catch {
-        // Skip malformed lines
-      }
-    }
-  }
-
-  _handleMessage(serverName, msg) {
-    const entry = this.servers.get(serverName);
-    if (!entry) return;
-
-    // Response to a request
-    if (msg.id !== undefined && entry._pending.has(msg.id)) {
-      const { resolve, reject, timeout } = entry._pending.get(msg.id);
-      clearTimeout(timeout);
-      entry._pending.delete(msg.id);
-
-      if (msg.error) {
-        reject(new Error(msg.error.message || "Unknown error"));
-      } else {
-        resolve(msg.result);
-      }
-      return;
-    }
-
-    // Server notification
-    if (msg.method) {
-      this.emit("notification", {
-        server: serverName,
-        method: msg.method,
-        params: msg.params,
-      });
-    }
-  }
-}
-
-/**
- * MCP server configuration storage.
- * Persists server configs in the database.
- */
-export class MCPServerConfig {
-  constructor(db) {
-    this.db = db;
-    this._ensureTable();
-  }
-
-  _ensureTable() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS mcp_servers (
-        name TEXT PRIMARY KEY,
-        command TEXT NOT NULL,
-        args TEXT DEFAULT '[]',
-        env TEXT DEFAULT '{}',
-        auto_connect INTEGER DEFAULT 0,
-        created_at TEXT DEFAULT (datetime('now')),
-        updated_at TEXT DEFAULT (datetime('now'))
-      )
-    `);
-  }
-
-  add(name, config) {
-    this.db
-      .prepare(
-        "INSERT OR REPLACE INTO mcp_servers (name, command, args, env, auto_connect, updated_at) VALUES (?, ?, ?, ?, ?, datetime('now'))",
-      )
-      .run(
-        name,
-        config.command,
-        JSON.stringify(config.args || []),
-        JSON.stringify(config.env || {}),
-        config.autoConnect ? 1 : 0,
-      );
-  }
-
-  remove(name) {
-    const result = this.db
-      .prepare("DELETE FROM mcp_servers WHERE name = ?")
-      .run(name);
-    return result.changes > 0;
-  }
-
-  get(name) {
-    const row = this.db
-      .prepare("SELECT * FROM mcp_servers WHERE name = ?")
-      .get(name);
-    if (!row) return null;
-    return {
-      name: row.name,
-      command: row.command,
-      args: JSON.parse(row.args || "[]"),
-      env: JSON.parse(row.env || "{}"),
-      autoConnect: row.auto_connect === 1,
-    };
-  }
-
-  list() {
-    const rows = this.db
-      .prepare("SELECT * FROM mcp_servers ORDER BY name")
-      .all();
-    return rows.map((row) => ({
-      name: row.name,
-      command: row.command,
-      args: JSON.parse(row.args || "[]"),
-      env: JSON.parse(row.env || "{}"),
-      autoConnect: row.auto_connect === 1,
-    }));
-  }
-
-  getAutoConnect() {
-    const rows = this.db
-      .prepare("SELECT * FROM mcp_servers WHERE auto_connect = ? ORDER BY name")
-      .all(1);
-    return rows.map((row) => ({
-      name: row.name,
-      command: row.command,
-      args: JSON.parse(row.args || "[]"),
-      env: JSON.parse(row.env || "{}"),
-      autoConnect: true,
-    }));
-  }
-}
+ * @deprecated — canonical implementation lives in `../harness/mcp-client.js`
+ * as of the CLI Runtime Convergence roadmap (Phase 3, 2026-04-09).
+ * This file is retained as a re-export shim for backwards compatibility
+ * and will be removed once all external consumers have migrated.
+ *
+ * Please import `MCPClient`, `MCPServerConfig`, and `ServerState` directly
+ * from `packages/cli/src/harness/mcp-client.js` in new code.
+ */
+
+export {
+  ServerState,
+  MCPClient,
+  MCPServerConfig,
+} from "../harness/mcp-client.js";