midsummer-sol 0.1.1

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "midsummer-sol",
+  "version": "0.1.1",
+  "description": "Sol — agent-native version control (a new git). CLI, MCP server, and no-filesystem SDK.",
+  "bin": {
+    "sol": "./sol.js",
+    "sol-mcp": "./sol-mcp.js"
+  },
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js"
+  },
+  "type": "module",
+  "files": [
+    "sol.js",
+    "sol-mcp.js",
+    "index.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "Apache-2.0",
+  "keywords": [
+    "vcs",
+    "git",
+    "version-control",
+    "agent",
+    "mcp",
+    "no-filesystem"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/sol-mcp.js

@@ -0,0 +1,638 @@
+#!/usr/bin/env node
+// @bun
+
+// src/bin/sol-mcp.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/file-store.ts
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { gunzipSync, gzipSync } from "node:zlib";
+
+// src/attest.ts
+function canonicalOp(op) {
+  return JSON.stringify({
+    seq: op.seq,
+    type: op.type,
+    path: op.path,
+    rootAfter: op.rootAfter,
+    by: op.by ?? null,
+    message: op.message ?? null
+  });
+}
+
+// src/errors.ts
+class CorruptRepoError extends Error {
+  constructor(message) {
+    super(`corrupt repo: ${message}`);
+    this.name = "CorruptRepoError";
+  }
+}
+
+class CorruptObjectError extends Error {
+  hash;
+  constructor(hash, message = "stored bytes do not hash to their content address") {
+    super(`corrupt object ${hash}: ${message}`);
+    this.hash = hash;
+    this.name = "CorruptObjectError";
+  }
+}
+
+// src/store.ts
+import { createHash } from "node:crypto";
+function hashString(s) {
+  return "h_" + createHash("sha256").update(s, "utf8").digest("hex");
+}
+function hashNode(node) {
+  let canon;
+  if (node.kind === "blob") {
+    canon = node.encoding ? `blob\x00${node.encoding}\x00${node.content}` : `blob\x00${node.content}`;
+  } else if (node.kind === "sealed")
+    canon = `sealed\x00${node.box}`;
+  else
+    canon = "tree\x00" + Object.keys(node.entries).sort().map((k) => {
+      const e = node.entries[k];
+      return e.mode === undefined ? `${k}\x00${e.kind}\x00${e.hash}` : `${k}\x00${e.kind}\x00${e.hash}\x00${e.mode}`;
+    }).join(`
+`);
+  return hashString(canon);
+}
+
+class Store {
+  objects = new Map;
+  put(node) {
+    const h = hashNode(node);
+    if (!this.objects.has(h))
+      this.objects.set(h, node);
+    return h;
+  }
+  get(h) {
+    return this.objects.get(h);
+  }
+  getTree(h) {
+    const n = this.get(h);
+    if (!n || n.kind !== "tree")
+      throw new Error(`not a tree: ${h}`);
+    return n;
+  }
+  has(h) {
+    return this.get(h) !== undefined;
+  }
+  size() {
+    return this.objects.size;
+  }
+}
+
+// src/chain.ts
+function hashEntry(prevHash, op) {
+  return hashString(canonicalOp(op) + "\x00" + (prevHash ?? ""));
+}
+function chainOp(prevHash, op) {
+  return { ...op, prevHash, entryHash: hashEntry(prevHash, op) };
+}
+
+// src/async-store.ts
+async function getTree(store, hash) {
+  const node = await store.get(hash);
+  if (!node || node.kind !== "tree")
+    throw new Error(`not a tree: ${hash}`);
+  return node;
+}
+
+class MemoryAsyncStore {
+  nodes = new Map;
+  async put(node) {
+    const h = hashNode(node);
+    if (!this.nodes.has(h))
+      this.nodes.set(h, node);
+    return h;
+  }
+  async get(hash) {
+    return this.nodes.get(hash);
+  }
+  async has(hash) {
+    return this.nodes.has(hash);
+  }
+  get size() {
+    return this.nodes.size;
+  }
+}
+
+// src/async-tree.ts
+function segments(path) {
+  return path.split("/").filter(Boolean);
+}
+async function emptyRoot(store) {
+  return store.put({ kind: "tree", entries: {} });
+}
+async function writeFile(store, root, path, content, opts = {}) {
+  const blob = opts.encoding ? { kind: "blob", content, encoding: opts.encoding } : { kind: "blob", content };
+  const hash = await store.put(blob);
+  return writeInto(store, root, segments(path), hash, "blob", opts.mode);
+}
+async function writeSealed(store, root, path, box) {
+  const hash = await store.put({ kind: "sealed", box });
+  return writeInto(store, root, segments(path), hash, "sealed");
+}
+async function writeInto(store, treeHash, segs, hash, leafKind, mode) {
+  const tree = await getTree(store, treeHash);
+  const entries = { ...tree.entries };
+  const [head, ...rest] = segs;
+  if (rest.length === 0) {
+    entries[head] = mode === undefined ? { kind: leafKind, hash } : { kind: leafKind, hash, mode };
+  } else {
+    const child = entries[head];
+    const childHash = child?.kind === "tree" ? child.hash : await emptyRoot(store);
+    entries[head] = { kind: "tree", hash: await writeInto(store, childHash, rest, hash, leafKind, mode) };
+  }
+  return store.put({ kind: "tree", entries });
+}
+async function applyBatch(store, root, changes) {
+  if (changes.size === 0)
+    return root;
+  const tree = await getTree(store, root);
+  const entries = { ...tree.entries };
+  const subdirs = new Map;
+  for (const [path, leaf] of changes) {
+    const i = path.indexOf("/");
+    if (i === -1) {
+      if (leaf === null)
+        delete entries[path];
+      else
+        entries[path] = leaf.mode === undefined ? { kind: leaf.kind, hash: leaf.hash } : { kind: leaf.kind, hash: leaf.hash, mode: leaf.mode };
+    } else {
+      const head = path.slice(0, i);
+      let m = subdirs.get(head);
+      if (!m) {
+        m = new Map;
+        subdirs.set(head, m);
+      }
+      m.set(path.slice(i + 1), leaf);
+    }
+  }
+  for (const [name, sub] of subdirs) {
+    const child = entries[name];
+    const childRoot = child && child.kind === "tree" ? child.hash : await emptyRoot(store);
+    const built = await applyBatch(store, childRoot, sub);
+    const builtTree = await getTree(store, built);
+    if (Object.keys(builtTree.entries).length === 0)
+      delete entries[name];
+    else
+      entries[name] = { kind: "tree", hash: built };
+  }
+  return store.put({ kind: "tree", entries });
+}
+async function deleteFile(store, root, path) {
+  return deleteInto(store, root, segments(path));
+}
+async function deleteInto(store, treeHash, segs) {
+  const tree = await getTree(store, treeHash);
+  const entries = { ...tree.entries };
+  const [head, ...rest] = segs;
+  if (!entries[head])
+    return treeHash;
+  if (rest.length === 0) {
+    delete entries[head];
+  } else if (entries[head].kind === "tree") {
+    entries[head] = { kind: "tree", hash: await deleteInto(store, entries[head].hash, rest) };
+  }
+  return store.put({ kind: "tree", entries });
+}
+async function nodeAt(store, root, path) {
+  const segs = segments(path);
+  let cur = root;
+  for (let i = 0;i < segs.length; i++) {
+    const entry = (await getTree(store, cur)).entries[segs[i]];
+    if (!entry)
+      return;
+    if (i === segs.length - 1) {
+      if (entry.kind === "tree")
+        return;
+      const node = await store.get(entry.hash);
+      if (!node)
+        return;
+      if (node.kind === "blob")
+        return { kind: "blob", content: node.content };
+      if (node.kind === "sealed")
+        return { kind: "sealed", box: node.box };
+      return;
+    }
+    if (entry.kind !== "tree")
+      return;
+    cur = entry.hash;
+  }
+  return;
+}
+async function fileAt(store, root, path) {
+  const segs = segments(path);
+  let cur = root;
+  for (let i = 0;i < segs.length; i++) {
+    const entry = (await getTree(store, cur)).entries[segs[i]];
+    if (!entry)
+      return;
+    if (i === segs.length - 1) {
+      if (entry.kind !== "blob")
+        return;
+      const node = await store.get(entry.hash);
+      return node && node.kind === "blob" ? node : undefined;
+    }
+    if (entry.kind !== "tree")
+      return;
+    cur = entry.hash;
+  }
+  return;
+}
+async function modeAt(store, root, path) {
+  const segs = segments(path);
+  let cur = root;
+  for (let i = 0;i < segs.length; i++) {
+    const entry = (await getTree(store, cur)).entries[segs[i]];
+    if (!entry)
+      return;
+    if (i === segs.length - 1)
+      return entry.mode;
+    if (entry.kind !== "tree")
+      return;
+    cur = entry.hash;
+  }
+  return;
+}
+async function listAll(store, root, prefix = "") {
+  const tree = await getTree(store, root);
+  const out = [];
+  for (const [name, entry] of Object.entries(tree.entries)) {
+    const p = prefix ? `${prefix}/${name}` : name;
+    if (entry.kind === "tree")
+      out.push(...await listAll(store, entry.hash, p));
+    else
+      out.push(p);
+  }
+  return out.sort();
+}
+
+// src/types.ts
+var SEALED = "<<sealed>>";
+
+// src/async-repo.ts
+function pageOps(ops, opts = {}) {
+  let out = opts.from !== undefined ? ops.filter((o) => o.seq >= opts.from) : ops.slice();
+  if (opts.limit !== undefined)
+    out = out.slice(0, opts.limit);
+  return out;
+}
+class AsyncRepo {
+  store;
+  log;
+  actor;
+  constructor(store, log, actor = "anon") {
+    this.store = store;
+    this.log = log;
+    this.actor = actor;
+  }
+  async currentRoot() {
+    const head = await this.log.head();
+    if (head === undefined) {
+      const seq = await this.log.seq();
+      if (seq > 0)
+        throw new CorruptRepoError(`op-log has ${seq} op(s) but no head pointer — head is lost`);
+      return emptyRoot(this.store);
+    }
+    if (!await this.store.has(head)) {
+      throw new CorruptRepoError(`head ${head} references a node missing from the store — dangling head`);
+    }
+    return head;
+  }
+  async writeFile(path, content, at = Date.now(), by = this.actor) {
+    const rootAfter = await writeFile(this.store, await this.currentRoot(), path, content);
+    await this.log.append({ seq: await this.log.seq() + 1, type: "write", path, rootAfter, at, by });
+    return rootAfter;
+  }
+  async applyBatch(changes) {
+    const root = await this.currentRoot();
+    const leaves = new Map;
+    for (const c of changes) {
+      if ("delete" in c) {
+        leaves.set(c.path, null);
+        continue;
+      }
+      const blob = c.encoding ? { kind: "blob", content: c.content, encoding: c.encoding } : { kind: "blob", content: c.content };
+      const hash = await this.store.put(blob);
+      leaves.set(c.path, { kind: "blob", hash, mode: c.mode });
+    }
+    return { root: await applyBatch(this.store, root, leaves), changed: changes.length };
+  }
+  async writeBytes(path, data, at = Date.now(), by = this.actor) {
+    const rootAfter = await writeFile(this.store, await this.currentRoot(), path, Buffer.from(data).toString("base64"), { encoding: "base64" });
+    await this.log.append({ seq: await this.log.seq() + 1, type: "write", path, rootAfter, at, by });
+    return rootAfter;
+  }
+  async readBytes(path) {
+    const leaf = await this.read(path);
+    if (!leaf)
+      return;
+    if (leaf.kind === "sealed")
+      return SEALED;
+    const f = await fileAt(this.store, await this.currentRoot(), path);
+    if (!f)
+      return;
+    return new Uint8Array(Buffer.from(f.content, f.encoding === "base64" ? "base64" : "utf8"));
+  }
+  async chmod(path, mode, at = Date.now()) {
+    const f = await fileAt(this.store, await this.currentRoot(), path);
+    if (!f)
+      return this.currentRoot();
+    const rootAfter = await writeFile(this.store, await this.currentRoot(), path, f.content, { encoding: f.encoding, mode });
+    await this.log.append({ seq: await this.log.seq() + 1, type: "write", path, rootAfter, at, by: this.actor });
+    return rootAfter;
+  }
+  async mode(path) {
+    return modeAt(this.store, await this.currentRoot(), path);
+  }
+  async writeSealed(path, box, at = Date.now()) {
+    const rootAfter = await writeSealed(this.store, await this.currentRoot(), path, box);
+    await this.log.append({ seq: await this.log.seq() + 1, type: "seal", path, rootAfter, at, by: this.actor });
+    return rootAfter;
+  }
+  async read(path) {
+    return nodeAt(this.store, await this.currentRoot(), path);
+  }
+  async deleteFile(path, at = Date.now(), by = this.actor) {
+    const rootAfter = await deleteFile(this.store, await this.currentRoot(), path);
+    await this.log.append({ seq: await this.log.seq() + 1, type: "delete", path, rootAfter, at, by });
+    return rootAfter;
+  }
+  async readFile(path) {
+    const leaf = await this.read(path);
+    if (!leaf)
+      return;
+    return leaf.kind === "sealed" ? SEALED : leaf.content;
+  }
+  async list() {
+    return listAll(this.store, await this.currentRoot());
+  }
+  async head() {
+    return this.currentRoot();
+  }
+  async history(opts) {
+    return this.log.history(opts);
+  }
+}
+
+// src/file-store.ts
+function encodeObject(node) {
+  return gzipSync(JSON.stringify(node), { level: 1 });
+}
+function decodeObject(raw) {
+  const json = raw.length >= 2 && raw[0] === 31 && raw[1] === 139 ? gunzipSync(raw).toString("utf8") : raw.toString("utf8");
+  return JSON.parse(json);
+}
+
+class FileStore {
+  objects;
+  constructor(solDir) {
+    this.objects = join(solDir, "objects");
+    mkdirSync(this.objects, { recursive: true });
+  }
+  path(hash) {
+    return join(this.objects, hash);
+  }
+  async put(node) {
+    const h = hashNode(node);
+    const p = this.path(h);
+    if (!existsSync(p)) {
+      const tmp = `${p}.tmp`;
+      writeFileSync(tmp, encodeObject(node));
+      renameSync(tmp, p);
+    }
+    return h;
+  }
+  async get(hash) {
+    const p = this.path(hash);
+    if (!existsSync(p))
+      return;
+    const node = decodeObject(readFileSync(p));
+    if (hashNode(node) !== hash)
+      throw new CorruptObjectError(hash);
+    return node;
+  }
+  async has(hash) {
+    return existsSync(this.path(hash));
+  }
+  count() {
+    return existsSync(this.objects) ? readdirSync(this.objects).length : 0;
+  }
+}
+
+class FileOpLog {
+  opsFile;
+  headFile;
+  constructor(solDir) {
+    this.opsFile = join(solDir, "ops.jsonl");
+    this.headFile = join(solDir, "HEAD");
+  }
+  readHead() {
+    return existsSync(this.headFile) ? JSON.parse(readFileSync(this.headFile, "utf8")) : { seq: 0 };
+  }
+  async head() {
+    return this.readHead().head;
+  }
+  async seq() {
+    return this.readHead().seq ?? 0;
+  }
+  async logTip() {
+    return this.readHead().logTip;
+  }
+  async append(entry) {
+    const chained = chainOp(this.readHead().logTip, entry);
+    appendFileSync(this.opsFile, JSON.stringify(chained) + `
+`);
+    writeFileSync(this.headFile, JSON.stringify({ head: chained.rootAfter, seq: chained.seq, logTip: chained.entryHash }));
+  }
+  async history(opts) {
+    if (!existsSync(this.opsFile))
+      return [];
+    const all = [];
+    for (const l of readFileSync(this.opsFile, "utf8").split(`
+`)) {
+      if (!l)
+        continue;
+      try {
+        all.push(JSON.parse(l));
+      } catch {
+        break;
+      }
+    }
+    return pageOps(all, opts);
+  }
+}
+
+// src/workspace.ts
+function safePath(path) {
+  const p = path.replace(/^\.[\\/]+/, "").trim();
+  if (!p)
+    throw new Error("path: empty");
+  if (p.startsWith("/") || p.startsWith("\\") || /^[a-zA-Z]:[\\/]/.test(p))
+    throw new Error(`path: absolute paths are not allowed: ${path}`);
+  if (p.split(/[\\/]/).some((s) => s === ".."))
+    throw new Error(`path: '..' escapes the workspace: ${path}`);
+  return p;
+}
+
+class SolWorkspace {
+  store;
+  log;
+  actor;
+  repo;
+  constructor(store, log, actor = "agent") {
+    this.store = store;
+    this.log = log;
+    this.actor = actor;
+    this.repo = new AsyncRepo(store, log, actor);
+  }
+  async write(path, content) {
+    return this.repo.writeFile(safePath(path), content);
+  }
+  async writeBytes(path, bytes) {
+    return this.repo.writeBytes(safePath(path), bytes);
+  }
+  async read(path) {
+    const c = await this.repo.readFile(path);
+    return c === undefined || c === SEALED ? undefined : c;
+  }
+  async readBytes(path) {
+    const b = await this.repo.readBytes(path);
+    return b === undefined || b === SEALED ? undefined : b;
+  }
+  async edit(path, oldStr, newStr, opts = {}) {
+    path = safePath(path);
+    const cur = await this.repo.readFile(path);
+    if (cur === undefined)
+      throw new Error(`edit: no such file: ${path}`);
+    if (cur === SEALED)
+      throw new Error(`edit: cannot text-edit a sealed file: ${path}`);
+    const occurrences = cur.split(oldStr).length - 1;
+    if (occurrences === 0)
+      throw new Error(`edit: text not found in ${path}`);
+    if (occurrences > 1 && !opts.all)
+      throw new Error(`edit: text appears ${occurrences}x in ${path} — add surrounding context or pass all:true`);
+    await this.repo.writeFile(path, opts.all ? cur.split(oldStr).join(newStr) : cur.replace(oldStr, newStr));
+  }
+  async ls(prefix) {
+    const all = await this.repo.list();
+    if (!prefix)
+      return all;
+    const dir = prefix.endsWith("/") ? prefix : prefix + "/";
+    return all.filter((p) => p === prefix || p.startsWith(dir));
+  }
+  async exists(path) {
+    return (await this.repo.list()).includes(path);
+  }
+  async isSealed(path) {
+    return await this.repo.readFile(path) === SEALED;
+  }
+  async move(from, to) {
+    const c = await this.repo.readFile(from);
+    if (c === undefined)
+      throw new Error(`move: no such file: ${from}`);
+    if (c === SEALED)
+      throw new Error(`move: cannot move a sealed file via the text API: ${from}`);
+    await this.repo.writeFile(safePath(to), c);
+    await this.repo.deleteFile(from);
+  }
+  remove(path) {
+    return this.repo.deleteFile(path);
+  }
+  async commit(message) {
+    const head = await this.repo.head();
+    const hist = await this.log.history();
+    let parent;
+    for (let i = hist.length - 1;i >= 0; i--) {
+      if (hist[i].type === "checkpoint") {
+        parent = hist[i].rootAfter;
+        break;
+      }
+    }
+    const entry = { seq: await this.log.seq() + 1, type: "checkpoint", path: "", rootAfter: head, at: Date.now(), by: this.actor, message, ...parent && parent !== head ? { parent } : {} };
+    await this.log.append(entry);
+    return head;
+  }
+  checkpoint(message) {
+    return this.commit(message);
+  }
+  head() {
+    return this.repo.head();
+  }
+  history(opts) {
+    return this.repo.history(opts);
+  }
+  get raw() {
+    return this.repo;
+  }
+}
+
+// src/bin/sol-mcp.ts
+var solDir = process.env.SOL_DIR || join2(process.cwd(), ".sol");
+mkdirSync2(solDir, { recursive: true });
+var ws = new SolWorkspace(new FileStore(solDir), new FileOpLog(solDir), process.env.SOL_ACTOR || "agent");
+var tools = [
+  { name: "sol_write", description: "Create or overwrite a text file in the sol workspace. Authoring goes here \u2014 not to a disk.", inputSchema: { type: "object", properties: { path: { type: "string" }, content: { type: "string" } }, required: ["path", "content"] } },
+  { name: "sol_read", description: "Read a text file from the sol workspace.", inputSchema: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } },
+  { name: "sol_edit", description: "Replace a unique snippet in a file (set all=true to replace every occurrence).", inputSchema: { type: "object", properties: { path: { type: "string" }, old_str: { type: "string" }, new_str: { type: "string" }, all: { type: "boolean" } }, required: ["path", "old_str", "new_str"] } },
+  { name: "sol_ls", description: "List tracked files, optionally scoped to a directory prefix.", inputSchema: { type: "object", properties: { prefix: { type: "string" } } } },
+  { name: "sol_move", description: "Move or rename a file.", inputSchema: { type: "object", properties: { from: { type: "string" }, to: { type: "string" } }, required: ["from", "to"] } },
+  { name: "sol_rm", description: "Delete (untrack) a file.", inputSchema: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } },
+  { name: "sol_commit", description: "Record a commit (a shareable milestone) over the current state.", inputSchema: { type: "object", properties: { message: { type: "string" } }, required: ["message"] } },
+  { name: "sol_history", description: "Show the authoring history (the op-log).", inputSchema: { type: "object", properties: {} } }
+];
+var text = (s) => ({ content: [{ type: "text", text: s }] });
+async function handle(name, a) {
+  switch (name) {
+    case "sol_write":
+      await ws.write(a.path, a.content);
+      return text(`wrote ${a.path} (${a.content.length} chars)`);
+    case "sol_read": {
+      const c = await ws.read(a.path);
+      return c === undefined ? text(`(absent: ${a.path})`) : text(c);
+    }
+    case "sol_edit":
+      await ws.edit(a.path, a.old_str, a.new_str, { all: a.all });
+      return text(`edited ${a.path}`);
+    case "sol_ls": {
+      const f = await ws.ls(a.prefix);
+      return text(f.length ? f.join(`
+`) : "(no files yet)");
+    }
+    case "sol_move":
+      await ws.move(a.from, a.to);
+      return text(`moved ${a.from} -> ${a.to}`);
+    case "sol_rm":
+      await ws.remove(a.path);
+      return text(`removed ${a.path}`);
+    case "sol_commit":
+    case "sol_checkpoint": {
+      const h = await ws.commit(a.message);
+      return text(`commit ${h.slice(0, 14)} \u2014 ${a.message}`);
+    }
+    case "sol_history": {
+      const ops = await ws.history();
+      return text(ops.map((o) => `${o.seq} ${o.type} ${o.path || ""}${o.message ? " : " + o.message : ""}`).join(`
+`) || "(empty)");
+    }
+    default:
+      throw new Error("unknown tool: " + name);
+  }
+}
+var server = new Server({ name: "sol", version: "0.1.0" }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  try {
+    return await handle(req.params.name, req.params.arguments ?? {});
+  } catch (e) {
+    return { content: [{ type: "text", text: "sol error: " + (e?.message ?? e) }], isError: true };
+  }
+});
+await server.connect(new StdioServerTransport);