@aprovan/hardcopy 0.1.0

package/dist/index.js

@@ -0,0 +1,2737 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/.pnpm/tsup@8.5.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/.pnpm/tsup@8.5.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/format.ts
+import matter from "gray-matter";
+function registerFormat(handler) {
+  handlers.set(handler.type, handler);
+}
+function getFormat(type) {
+  return handlers.get(type);
+}
+function listFormats() {
+  return Array.from(handlers.keys());
+}
+function renderNode(node, template) {
+  if (template) {
+    return renderTemplate(template, node);
+  }
+  const handler = handlers.get(node.type);
+  if (!handler) {
+    throw new Error(`No format handler for type: ${node.type}`);
+  }
+  return handler.render(node);
+}
+function parseFile(content, type) {
+  const handler = handlers.get(type);
+  if (!handler) {
+    return parseGeneric(content);
+  }
+  return handler.parse(content);
+}
+function parseGeneric(content) {
+  const { data, content: body } = matter(content);
+  return { attrs: data, body: body.trim() };
+}
+function renderTemplate(template, node) {
+  return template.replace(/\{\{([^}]+)\}\}/g, (_, path2) => {
+    const value = resolvePath(
+      node,
+      path2.trim()
+    );
+    return value?.toString() ?? "";
+  });
+}
+function resolvePath(obj, path2) {
+  const parts = path2.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+var handlers;
+var init_format = __esm({
+  "src/format.ts"() {
+    "use strict";
+    init_esm_shims();
+    handlers = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/crdt.ts
+import { LoroDoc } from "loro-crdt";
+import { readFile as readFile2, writeFile, mkdir, access, rm } from "fs/promises";
+import { dirname as dirname2, join as join2 } from "path";
+function setDocContent(doc, content) {
+  const text = doc.getText("body");
+  const current = text.toString();
+  if (current !== content) {
+    text.delete(0, current.length);
+    text.insert(0, content);
+  }
+}
+function getDocContent(doc) {
+  return doc.getText("body").toString();
+}
+function setDocAttrs(doc, attrs) {
+  const map = doc.getMap("attrs");
+  for (const [key, value] of Object.entries(attrs)) {
+    map.set(key, value);
+  }
+}
+function getDocAttrs(doc) {
+  const map = doc.getMap("attrs");
+  const result = {};
+  for (const key of map.keys()) {
+    result[key] = map.get(key);
+  }
+  return result;
+}
+var CRDTStore;
+var init_crdt = __esm({
+  "src/crdt.ts"() {
+    "use strict";
+    init_esm_shims();
+    CRDTStore = class {
+      basePath;
+      constructor(basePath) {
+        this.basePath = basePath;
+      }
+      getPath(nodeId) {
+        const encoded = encodeURIComponent(nodeId);
+        return join2(this.basePath, `${encoded}.loro`);
+      }
+      async exists(nodeId) {
+        try {
+          await access(this.getPath(nodeId));
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async load(nodeId) {
+        const path2 = this.getPath(nodeId);
+        try {
+          const data = await readFile2(path2);
+          const doc = new LoroDoc();
+          doc.import(new Uint8Array(data));
+          return doc;
+        } catch {
+          return null;
+        }
+      }
+      async save(nodeId, doc) {
+        const path2 = this.getPath(nodeId);
+        await mkdir(dirname2(path2), { recursive: true });
+        const snapshot = doc.export({ mode: "snapshot" });
+        await writeFile(path2, Buffer.from(snapshot));
+      }
+      async create(nodeId) {
+        const doc = new LoroDoc();
+        await this.save(nodeId, doc);
+        return doc;
+      }
+      async loadOrCreate(nodeId) {
+        const existing = await this.load(nodeId);
+        if (existing) return existing;
+        return this.create(nodeId);
+      }
+      async delete(nodeId) {
+        try {
+          await rm(this.getPath(nodeId));
+        } catch {
+        }
+      }
+      async merge(nodeId, remote) {
+        const local = await this.loadOrCreate(nodeId);
+        local.import(remote.export({ mode: "update" }));
+        await this.save(nodeId, local);
+        return local;
+      }
+    };
+  }
+});
+
+// src/hardcopy/views.ts
+import { join as join6 } from "path";
+import { mkdir as mkdir4, writeFile as writeFile3, readFile as readFile6, rm as rm3, readdir as readdir2, stat } from "fs/promises";
+async function getViews() {
+  const config = await this.loadConfig();
+  return config.views.map((v) => v.path);
+}
+async function refreshView(viewPath, options = {}) {
+  const config = await this.loadConfig();
+  const view = config.views.find((v) => v.path === viewPath);
+  if (!view) throw new Error(`View not found: ${viewPath}`);
+  const viewDir = join6(this.root, view.path);
+  await mkdir4(viewDir, { recursive: true });
+  const db = this.getDatabase();
+  const params = {};
+  const me = process.env["HARDCOPY_ME"] ?? process.env["GITHUB_USER"];
+  if (me) params["me"] = me;
+  const nodes = await db.queryViewNodes(
+    view.query,
+    Object.keys(params).length ? params : void 0
+  );
+  const indexState = {
+    loaded: nodes.length,
+    pageSize: 10,
+    lastFetch: (/* @__PURE__ */ new Date()).toISOString(),
+    ttl: 300
+  };
+  await writeFile3(
+    join6(viewDir, ".index"),
+    JSON.stringify(indexState, null, 2)
+  );
+  const expectedFiles = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    const renderedPaths = await renderNodeToFile.call(this, node, view, viewDir);
+    for (const p of renderedPaths) {
+      expectedFiles.add(p);
+    }
+  }
+  const existingFiles = await listViewFiles(viewDir);
+  const orphanedFiles = existingFiles.filter((f) => !expectedFiles.has(f));
+  if (options.clean && orphanedFiles.length > 0) {
+    await cleanupOrphanedFiles.call(this, viewDir, orphanedFiles);
+  }
+  return {
+    rendered: expectedFiles.size,
+    orphaned: orphanedFiles,
+    cleaned: options.clean ?? false
+  };
+}
+async function renderNodeToFile(node, view, viewDir) {
+  const renderedPaths = [];
+  const crdt = this.getCRDTStore();
+  const db = this.getDatabase();
+  for (const renderConfig of view.render) {
+    const filePath = resolveRenderPath(renderConfig.path, node);
+    const fullPath = join6(viewDir, filePath);
+    await mkdir4(join6(fullPath, ".."), { recursive: true });
+    let content;
+    if (renderConfig.template) {
+      content = renderNode(node, renderConfig.template);
+    } else if (renderConfig.type) {
+      content = renderNode({ ...node, type: renderConfig.type });
+    } else {
+      content = renderNode(node);
+    }
+    const doc = await crdt.loadOrCreate(node.id);
+    const body = node.attrs["body"] ?? "";
+    setDocContent(doc, body);
+    setDocAttrs(doc, node.attrs);
+    await crdt.save(node.id, doc);
+    await writeFile3(fullPath, content);
+    const fileStat = await stat(fullPath);
+    await db.upsertNode({ ...node, syncedAt: fileStat.mtimeMs });
+    renderedPaths.push(filePath);
+  }
+  return renderedPaths;
+}
+function resolveRenderPath(template, node) {
+  return template.replace(/\{\{([^}]+)\}\}/g, (_, path2) => {
+    const parts = path2.trim().split(".");
+    let current = { ...node, ...node.attrs };
+    for (const part of parts) {
+      if (current === null || current === void 0) return "";
+      current = current[part];
+    }
+    return String(current ?? "");
+  });
+}
+async function listViewFiles(viewDir) {
+  const files = [];
+  async function walk(dir, base) {
+    let entries;
+    try {
+      entries = await readdir2(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const relPath = base ? `${base}/${entry.name}` : entry.name;
+      if (entry.name.startsWith(".")) continue;
+      if (entry.isDirectory()) {
+        await walk(join6(dir, entry.name), relPath);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        files.push(relPath);
+      }
+    }
+  }
+  await walk(viewDir, "");
+  return files;
+}
+async function cleanupOrphanedFiles(viewDir, orphanedFiles) {
+  for (const relPath of orphanedFiles) {
+    const fullPath = join6(viewDir, relPath);
+    await syncFileBeforeDelete.call(this, fullPath);
+    try {
+      await rm3(fullPath);
+      console.log(`Deleted orphaned file: ${relPath}`);
+    } catch (err) {
+      console.error(`Failed to delete ${relPath}: ${err}`);
+    }
+  }
+}
+async function syncFileBeforeDelete(fullPath) {
+  try {
+    const content = await readFile6(fullPath, "utf-8");
+    const parsed = parseFile(content, "generic");
+    const nodeId = parsed.attrs._id ?? parsed.attrs.id;
+    if (!nodeId) return;
+    const crdt = this.getCRDTStore();
+    const doc = await crdt.load(nodeId);
+    if (!doc) return;
+    const crdtContent = getDocContent(doc);
+    if (parsed.body !== crdtContent) {
+      console.warn(
+        `Warning: File for ${nodeId} has local changes that may be lost. Run 'hardcopy push' first to preserve changes.`
+      );
+    }
+    await crdt.delete(nodeId);
+  } catch {
+  }
+}
+var init_views = __esm({
+  "src/hardcopy/views.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_crdt();
+    init_format();
+  }
+});
+
+// src/hardcopy/diff.ts
+var diff_exports = {};
+__export(diff_exports, {
+  detectChanges: () => detectChanges,
+  diff: () => diff,
+  getChangedFiles: () => getChangedFiles
+});
+import { join as join7 } from "path";
+import { readFile as readFile7, stat as stat2 } from "fs/promises";
+import { minimatch } from "minimatch";
+async function getChangedFiles(pattern) {
+  const config = await this.loadConfig();
+  const db = this.getDatabase();
+  const changedFiles = [];
+  for (const view of config.views) {
+    const viewDir = join7(this.root, view.path);
+    const files = await listViewFiles(viewDir);
+    for (const relPath of files) {
+      const fullPath = join7(viewDir, relPath);
+      const viewRelPath = join7(view.path, relPath);
+      if (pattern && !minimatch(viewRelPath, pattern) && !viewRelPath.startsWith(pattern)) {
+        continue;
+      }
+      const fileStat = await stat2(fullPath).catch(() => null);
+      if (!fileStat) continue;
+      const content = await readFile7(fullPath, "utf-8");
+      const parsed = parseFile(content, "generic");
+      const nodeId = parsed.attrs._id ?? parsed.attrs.id;
+      if (!nodeId) continue;
+      const dbNode = await db.getNode(nodeId);
+      const fileMtime = fileStat.mtimeMs;
+      const syncedAt = dbNode?.syncedAt ?? 0;
+      if (fileMtime > syncedAt) {
+        changedFiles.push({
+          path: viewRelPath,
+          fullPath,
+          nodeId,
+          nodeType: dbNode?.type ?? parsed.attrs._type ?? "unknown",
+          status: dbNode ? "modified" : "new",
+          mtime: fileMtime,
+          syncedAt
+        });
+      }
+    }
+  }
+  return changedFiles;
+}
+async function diff(pattern, options = {}) {
+  const config = await this.loadConfig();
+  const db = this.getDatabase();
+  const results = [];
+  const useSmart = options.smart !== false;
+  if (useSmart && pattern) {
+    const candidates = await getChangedFiles.call(this, pattern);
+    for (const candidate of candidates) {
+      const result = await diffFile.call(this, candidate.fullPath, db);
+      if (result && result.changes.length > 0) {
+        results.push(result);
+      }
+    }
+    return results;
+  }
+  for (const view of config.views) {
+    const viewDir = join7(this.root, view.path);
+    const files = await listViewFiles(viewDir);
+    for (const relPath of files) {
+      const fullPath = join7(viewDir, relPath);
+      const viewRelPath = join7(view.path, relPath);
+      if (pattern) {
+        const targetPath = join7(this.root, pattern);
+        const isExactMatch = fullPath === targetPath;
+        const isGlobMatch = minimatch(viewRelPath, pattern);
+        const isPrefixMatch = viewRelPath.startsWith(pattern);
+        if (!isExactMatch && !isGlobMatch && !isPrefixMatch) continue;
+      }
+      const result = await diffFile.call(this, fullPath, db);
+      if (result && result.changes.length > 0) {
+        results.push(result);
+      }
+    }
+  }
+  return results;
+}
+async function diffFile(fullPath, db) {
+  try {
+    const content = await readFile7(fullPath, "utf-8");
+    const parsed = parseFile(content, "generic");
+    const nodeId = parsed.attrs._id ?? parsed.attrs.id;
+    const nodeType = parsed.attrs._type;
+    if (!nodeId) return null;
+    const dbNode = await db.getNode(nodeId);
+    if (!dbNode) {
+      return {
+        nodeId,
+        nodeType: nodeType ?? "unknown",
+        filePath: fullPath,
+        changes: [{ field: "_new", oldValue: null, newValue: parsed.attrs }]
+      };
+    }
+    const format = getFormat(dbNode.type);
+    if (!format) return null;
+    const changes = detectChanges(parsed, dbNode, format.editableFields);
+    return {
+      nodeId,
+      nodeType: dbNode.type,
+      filePath: fullPath,
+      changes
+    };
+  } catch {
+    return null;
+  }
+}
+function detectChanges(parsed, dbNode, editableFields) {
+  const changes = [];
+  const dbAttrs = dbNode.attrs;
+  for (const field of editableFields) {
+    if (field === "body") {
+      const oldBody = (dbAttrs["body"] ?? "").trim();
+      const newBody = parsed.body.trim();
+      if (newBody !== oldBody) {
+        changes.push({ field: "body", oldValue: oldBody, newValue: newBody });
+      }
+    } else {
+      const oldValue = dbAttrs[field];
+      const newValue = parsed.attrs[field];
+      if (!valuesEqual2(oldValue, newValue)) {
+        changes.push({ field, oldValue, newValue });
+      }
+    }
+  }
+  return changes;
+}
+function valuesEqual2(a, b) {
+  if (a === b) return true;
+  if (a == null && b == null) return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((v, i) => valuesEqual2(v, b[i]));
+  }
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+var init_diff = __esm({
+  "src/hardcopy/diff.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_format();
+    init_views();
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+
+// src/types.ts
+init_esm_shims();
+var ConflictStatus = /* @__PURE__ */ ((ConflictStatus2) => {
+  ConflictStatus2["CLEAN"] = "clean";
+  ConflictStatus2["REMOTE_ONLY"] = "remote";
+  ConflictStatus2["DIVERGED"] = "diverged";
+  return ConflictStatus2;
+})(ConflictStatus || {});
+
+// src/provider.ts
+init_esm_shims();
+var providers = /* @__PURE__ */ new Map();
+function registerProvider(name, factory) {
+  providers.set(name, factory);
+}
+function getProvider(name) {
+  return providers.get(name);
+}
+function listProviders() {
+  return Array.from(providers.keys());
+}
+
+// src/index.ts
+init_format();
+
+// src/config.ts
+init_esm_shims();
+import { readFile } from "fs/promises";
+import yaml from "yaml";
+async function loadConfig(path2) {
+  const content = await readFile(path2, "utf-8");
+  return parseConfig(content);
+}
+function parseConfig(content) {
+  const parsed = yaml.parse(content);
+  return validateConfig(parsed);
+}
+function validateConfig(data) {
+  if (!data || typeof data !== "object") {
+    throw new Error("Config must be an object");
+  }
+  const config = data;
+  return {
+    sources: validateSources(config["sources"]),
+    views: validateViews(config["views"])
+  };
+}
+function validateSources(data) {
+  if (!Array.isArray(data)) {
+    return [];
+  }
+  return data.map((s, i) => {
+    if (!s || typeof s !== "object") {
+      throw new Error(`Source ${i} must be an object`);
+    }
+    const source = s;
+    if (typeof source["name"] !== "string") {
+      throw new Error(`Source ${i} must have a name`);
+    }
+    if (typeof source["provider"] !== "string") {
+      throw new Error(`Source ${i} must have a provider`);
+    }
+    return source;
+  });
+}
+function validateViews(data) {
+  if (!Array.isArray(data)) {
+    return [];
+  }
+  return data.map((v, i) => {
+    if (!v || typeof v !== "object") {
+      throw new Error(`View ${i} must be an object`);
+    }
+    const view = v;
+    if (typeof view["path"] !== "string") {
+      throw new Error(`View ${i} must have a path`);
+    }
+    if (typeof view["query"] !== "string") {
+      throw new Error(`View ${i} must have a query`);
+    }
+    if (!Array.isArray(view["render"])) {
+      throw new Error(`View ${i} must have render configs`);
+    }
+    return view;
+  });
+}
+
+// src/db.ts
+init_esm_shims();
+import BetterSqlite3 from "better-sqlite3";
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = dirname(fileURLToPath2(import.meta.url));
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS hc_nodes (
+  id TEXT PRIMARY KEY,
+  type TEXT NOT NULL,
+  attrs TEXT NOT NULL,
+  synced_at INTEGER,
+  version_token TEXT,
+  cursor TEXT
+);
+
+CREATE INDEX IF NOT EXISTS hc_idx_nodes_type ON hc_nodes(type);
+CREATE INDEX IF NOT EXISTS hc_idx_nodes_synced ON hc_nodes(synced_at);
+
+CREATE TABLE IF NOT EXISTS hc_edges (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  type TEXT NOT NULL,
+  from_id TEXT NOT NULL,
+  to_id TEXT NOT NULL,
+  attrs TEXT,
+  UNIQUE(type, from_id, to_id)
+);
+
+CREATE INDEX IF NOT EXISTS hc_idx_edges_from ON hc_edges(from_id);
+CREATE INDEX IF NOT EXISTS hc_idx_edges_to ON hc_edges(to_id);
+CREATE INDEX IF NOT EXISTS hc_idx_edges_type ON hc_edges(type);
+`;
+var GRAPHQLITE_ENV_PATH = "GRAPHQLITE_EXTENSION_PATH";
+var GRAPHQLITE_TEST_QUERY = "SELECT graphqlite_test() AS result";
+var HardcopyDatabase = class _HardcopyDatabase {
+  db;
+  graphqliteLoaded = false;
+  constructor(db) {
+    this.db = db;
+  }
+  static async open(path2) {
+    const db = new BetterSqlite3(path2);
+    const hcdb = new _HardcopyDatabase(db);
+    await hcdb.initialize();
+    return hcdb;
+  }
+  async initialize() {
+    await this.migrateLegacySchema();
+    const statements = SCHEMA.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
+    for (const sql of statements) {
+      this.db.exec(sql);
+    }
+  }
+  async migrateLegacySchema() {
+    const legacyNodes = this.getTableColumns("nodes");
+    const legacyEdges = this.getTableColumns("edges");
+    if (legacyNodes) {
+      const isLegacy = legacyNodes.includes("type") || legacyNodes.includes("attrs");
+      if (isLegacy) {
+        this.renameTableIfNeeded("nodes", "hc_nodes");
+        this.dropLegacyIndexes(["idx_nodes_type", "idx_nodes_synced"]);
+      }
+    }
+    if (legacyEdges) {
+      const isLegacy = legacyEdges.includes("from_id") || legacyEdges.includes("to_id");
+      if (isLegacy) {
+        this.renameTableIfNeeded("edges", "hc_edges");
+        this.dropLegacyIndexes([
+          "idx_edges_from",
+          "idx_edges_to",
+          "idx_edges_type"
+        ]);
+      }
+    }
+  }
+  getTableColumns(table) {
+    const stmt = this.db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name = ?"
+    );
+    const result = stmt.all(table);
+    if (result.length === 0) return null;
+    const columns = this.db.pragma(`table_info(${table})`);
+    return columns.map((row) => row.name);
+  }
+  renameTableIfNeeded(from, to) {
+    const stmt = this.db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name = ?"
+    );
+    const existing = stmt.all(to);
+    if (existing.length > 0) return;
+    this.db.exec(`ALTER TABLE ${from} RENAME TO ${to}`);
+  }
+  dropLegacyIndexes(names) {
+    for (const name of names) {
+      this.db.exec(`DROP INDEX IF EXISTS ${name}`);
+    }
+  }
+  resolveGraphqliteLoadPath() {
+    const envPath = process.env[GRAPHQLITE_ENV_PATH];
+    if (envPath) {
+      return envPath;
+    }
+    const extensionCandidates = this.getExtensionCandidates();
+    for (const candidate of extensionCandidates) {
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+  getExtensionCandidates() {
+    const platform = process.platform;
+    const arch = process.arch;
+    const filenames = [];
+    if (platform === "darwin" && arch === "arm64") {
+      filenames.push("graphqlite-macos-arm64.dylib");
+    } else if (platform === "darwin" && arch === "x64") {
+      filenames.push("graphqlite-macos-x86_64.dylib");
+    } else if (platform === "linux" && arch === "arm64") {
+      filenames.push("graphqlite-linux-aarch64.so");
+    } else if (platform === "linux" && arch === "x64") {
+      filenames.push("graphqlite-linux-x86_64.so");
+    } else if (platform === "win32" && arch === "x64") {
+      filenames.push("graphqlite-windows-x86_64.dll");
+    }
+    const searchDirs = [
+      join(__dirname2, "..", ".hardcopy", "extensions"),
+      join(process.cwd(), ".hardcopy", "extensions")
+    ];
+    const candidates = [];
+    for (const dir of searchDirs) {
+      for (const filename of filenames) {
+        candidates.push(join(dir, filename));
+      }
+    }
+    return candidates;
+  }
+  ensureGraphqliteLoaded() {
+    if (this.graphqliteLoaded) return;
+    try {
+      const stmt = this.db.prepare(GRAPHQLITE_TEST_QUERY);
+      const result = stmt.all();
+      const value2 = String(result[0]?.result ?? "");
+      if (value2.toLowerCase().includes("successfully")) {
+        this.graphqliteLoaded = true;
+        return;
+      }
+    } catch {
+    }
+    const loadPath = this.resolveGraphqliteLoadPath();
+    if (!loadPath) {
+      throw new Error(
+        `GraphQLite extension not found. Run \`pnpm setup:graphqlite\` or set ${GRAPHQLITE_ENV_PATH}.`
+      );
+    }
+    this.db.loadExtension(loadPath, "sqlite3_graphqlite_init");
+    const verifyStmt = this.db.prepare(GRAPHQLITE_TEST_QUERY);
+    const verify = verifyStmt.all();
+    const value = String(verify[0]?.result ?? "");
+    if (!value.toLowerCase().includes("successfully")) {
+      throw new Error("GraphQLite extension loaded but verification failed.");
+    }
+    this.graphqliteLoaded = true;
+  }
+  normalizeCypher(query) {
+    let normalized = query.replace(/->>'(\w+)'/g, ".$1");
+    normalized = normalized.replace(/\.attrs\.(\w+)/g, ".$1");
+    normalized = normalized.replace(
+      /:([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z0-9_]+)+)/g,
+      (_match, label) => `:\`${label}\``
+    );
+    return normalized;
+  }
+  escapeCypherType(value) {
+    const escaped = value.replace(/`/g, "``");
+    return `\`${escaped}\``;
+  }
+  extractNodeIds(rows) {
+    const ids = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      for (const [key, value] of Object.entries(row)) {
+        if (key === "node_id" && typeof value === "string") {
+          ids.add(value);
+          continue;
+        }
+        if (key.endsWith(".node_id") && typeof value === "string") {
+          ids.add(value);
+          continue;
+        }
+        if (key === "id" && typeof value === "string") {
+          ids.add(value);
+          continue;
+        }
+        if (key.endsWith(".id") && typeof value === "string") {
+          ids.add(value);
+          continue;
+        }
+        if (value && typeof value === "object") {
+          const obj = value;
+          if (typeof obj["node_id"] === "string") {
+            ids.add(obj["node_id"]);
+            continue;
+          }
+          const props = obj["properties"];
+          if (props && typeof props === "object") {
+            const propsObj = props;
+            if (typeof propsObj["node_id"] === "string") {
+              ids.add(propsObj["node_id"]);
+              continue;
+            }
+          }
+          if (typeof obj["id"] === "string") ids.add(obj["id"]);
+        }
+      }
+    }
+    return Array.from(ids);
+  }
+  parseCypherRows(rows) {
+    if (!rows.length) return [];
+    const row = rows[0];
+    const payload = row.result;
+    if (payload === null || payload === void 0) return [];
+    if (typeof payload !== "string") return [];
+    try {
+      const parsed = JSON.parse(payload);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  async cypher(query, params) {
+    this.ensureGraphqliteLoaded();
+    const normalized = this.normalizeCypher(query);
+    const stmt = params ? this.db.prepare("SELECT cypher(?, ?) AS result") : this.db.prepare("SELECT cypher(?) AS result");
+    const args = params ? [normalized, JSON.stringify(params)] : [normalized];
+    const result = stmt.all(...args);
+    return this.parseCypherRows(result);
+  }
+  async queryViewNodes(query, params) {
+    const rows = await this.cypher(query, params);
+    const ids = this.extractNodeIds(rows);
+    if (ids.length === 0) return [];
+    return this.getNodesByIds(ids);
+  }
+  async getNodesByIds(ids) {
+    if (ids.length === 0) return [];
+    const placeholders = ids.map(() => "?").join(", ");
+    const stmt = this.db.prepare(
+      `SELECT * FROM hc_nodes WHERE id IN (${placeholders})`
+    );
+    const result = stmt.all(...ids);
+    const byId = new Map(
+      result.map((row) => [
+        row["id"],
+        {
+          id: row["id"],
+          type: row["type"],
+          attrs: JSON.parse(row["attrs"]),
+          syncedAt: row["synced_at"],
+          versionToken: row["version_token"],
+          cursor: row["cursor"]
+        }
+      ])
+    );
+    return ids.map((id) => byId.get(id)).filter(Boolean);
+  }
+  async upsertNode(node) {
+    const stmt = this.db.prepare(
+      `INSERT INTO hc_nodes (id, type, attrs, synced_at, version_token, cursor)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         type = excluded.type,
+         attrs = excluded.attrs,
+         synced_at = excluded.synced_at,
+         version_token = excluded.version_token,
+         cursor = excluded.cursor`
+    );
+    stmt.run(
+      node.id,
+      node.type,
+      JSON.stringify(node.attrs),
+      node.syncedAt ?? null,
+      node.versionToken ?? null,
+      node.cursor ?? null
+    );
+    await this.upsertGraphNode(node);
+  }
+  async upsertNodes(nodes) {
+    if (nodes.length === 0) return;
+    const stmt = this.db.prepare(
+      `INSERT INTO hc_nodes (id, type, attrs, synced_at, version_token, cursor)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         type = excluded.type,
+         attrs = excluded.attrs,
+         synced_at = excluded.synced_at,
+         version_token = excluded.version_token,
+         cursor = excluded.cursor`
+    );
+    const insertMany = this.db.transaction((nodes2) => {
+      for (const node of nodes2) {
+        stmt.run(
+          node.id,
+          node.type,
+          JSON.stringify(node.attrs),
+          node.syncedAt ?? null,
+          node.versionToken ?? null,
+          node.cursor ?? null
+        );
+      }
+    });
+    insertMany(nodes);
+    for (const node of nodes) {
+      await this.upsertGraphNode(node);
+    }
+  }
+  async getNode(id) {
+    const stmt = this.db.prepare("SELECT * FROM hc_nodes WHERE id = ?");
+    const result = stmt.all(id);
+    if (result.length === 0) return null;
+    const row = result[0];
+    return {
+      id: row["id"],
+      type: row["type"],
+      attrs: JSON.parse(row["attrs"]),
+      syncedAt: row["synced_at"],
+      versionToken: row["version_token"],
+      cursor: row["cursor"]
+    };
+  }
+  async queryNodes(type) {
+    const sql = type ? "SELECT * FROM hc_nodes WHERE type = ?" : "SELECT * FROM hc_nodes";
+    const stmt = this.db.prepare(sql);
+    const result = type ? stmt.all(type) : stmt.all();
+    return result.map((row) => ({
+      id: row["id"],
+      type: row["type"],
+      attrs: JSON.parse(row["attrs"]),
+      syncedAt: row["synced_at"],
+      versionToken: row["version_token"],
+      cursor: row["cursor"]
+    }));
+  }
+  async deleteNode(id) {
+    const deleteEdgesStmt = this.db.prepare(
+      "DELETE FROM hc_edges WHERE from_id = ? OR to_id = ?"
+    );
+    deleteEdgesStmt.run(id, id);
+    const deleteNodeStmt = this.db.prepare("DELETE FROM hc_nodes WHERE id = ?");
+    deleteNodeStmt.run(id);
+    await this.deleteGraphNode(id);
+  }
+  async upsertEdge(edge) {
+    const stmt = this.db.prepare(
+      `INSERT INTO hc_edges (type, from_id, to_id, attrs)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(type, from_id, to_id) DO UPDATE SET
+         attrs = excluded.attrs`
+    );
+    stmt.run(
+      edge.type,
+      edge.fromId,
+      edge.toId,
+      edge.attrs ? JSON.stringify(edge.attrs) : null
+    );
+    await this.upsertGraphEdge(edge);
+  }
+  async upsertEdges(edges) {
+    if (edges.length === 0) return;
+    const stmt = this.db.prepare(
+      `INSERT INTO hc_edges (type, from_id, to_id, attrs)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(type, from_id, to_id) DO UPDATE SET
+         attrs = excluded.attrs`
+    );
+    const insertMany = this.db.transaction((edges2) => {
+      for (const edge of edges2) {
+        stmt.run(
+          edge.type,
+          edge.fromId,
+          edge.toId,
+          edge.attrs ? JSON.stringify(edge.attrs) : null
+        );
+      }
+    });
+    insertMany(edges);
+    for (const edge of edges) {
+      await this.upsertGraphEdge(edge);
+    }
+  }
+  async getEdges(fromId, toId, type) {
+    const conditions = [];
+    const args = [];
+    if (fromId) {
+      conditions.push("from_id = ?");
+      args.push(fromId);
+    }
+    if (toId) {
+      conditions.push("to_id = ?");
+      args.push(toId);
+    }
+    if (type) {
+      conditions.push("type = ?");
+      args.push(type);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const stmt = this.db.prepare(`SELECT * FROM hc_edges ${where}`);
+    const result = stmt.all(...args);
+    return result.map((row) => ({
+      id: row["id"],
+      type: row["type"],
+      fromId: row["from_id"],
+      toId: row["to_id"],
+      attrs: row["attrs"] ? JSON.parse(row["attrs"]) : void 0
+    }));
+  }
+  async deleteEdge(fromId, toId, type) {
+    const stmt = this.db.prepare(
+      "DELETE FROM hc_edges WHERE from_id = ? AND to_id = ? AND type = ?"
+    );
+    stmt.run(fromId, toId, type);
+    await this.deleteGraphEdge(fromId, toId, type);
+  }
+  escapeCypherString(value) {
+    return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  }
+  async upsertGraphNode(node) {
+    const label = this.escapeCypherType(node.type);
+    const escapedNodeId = this.escapeCypherString(node.id);
+    const flatAttrs = {
+      node_id: node.id,
+      node_type: node.type
+    };
+    if (node.attrs && typeof node.attrs === "object") {
+      for (const [key, value] of Object.entries(node.attrs)) {
+        if (value === null || value === void 0) {
+          flatAttrs[key] = null;
+        } else if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+          flatAttrs[key] = value;
+        } else if (Array.isArray(value)) {
+          flatAttrs[key] = JSON.stringify(value);
+        } else {
+          flatAttrs[key] = JSON.stringify(value);
+        }
+      }
+    }
+    const setClause = Object.keys(flatAttrs).map((k) => `n.${k} = $${k}`).join(", ");
+    await this.cypher(
+      `MERGE (n:${label} {node_id: '${escapedNodeId}'}) ON CREATE SET ${setClause} ON MATCH SET ${setClause}`,
+      flatAttrs
+    );
+  }
+  async upsertGraphEdge(edge) {
+    const relType = this.escapeCypherType(edge.type);
+    const escapedFromId = this.escapeCypherString(edge.fromId);
+    const escapedToId = this.escapeCypherString(edge.toId);
+    await this.cypher(
+      `MATCH (a {node_id: '${escapedFromId}'}), (b {node_id: '${escapedToId}'}) MERGE (a)-[r:${relType}]->(b)`
+    );
+  }
+  async deleteGraphNode(id) {
+    const escapedId = this.escapeCypherString(id);
+    await this.cypher(`MATCH (n {node_id: '${escapedId}'}) DETACH DELETE n`);
+  }
+  async deleteGraphEdge(fromId, toId, type) {
+    const relType = this.escapeCypherType(type);
+    const escapedFromId = this.escapeCypherString(fromId);
+    const escapedToId = this.escapeCypherString(toId);
+    await this.cypher(
+      `MATCH (a {node_id: '${escapedFromId}'})-[r:${relType}]->(b {node_id: '${escapedToId}'}) DELETE r`
+    );
+  }
+  async close() {
+    this.db.close();
+  }
+};
+
+// src/index.ts
+init_crdt();
+
+// src/hardcopy.ts
+init_esm_shims();
+
+// src/hardcopy/index.ts
+init_esm_shims();
+init_format();
+
+// src/formats/github-issue.ts
+init_esm_shims();
+import matter2 from "gray-matter";
+var githubIssueFormat = {
+  type: "github.Issue",
+  editableFields: ["title", "body", "labels", "assignee", "milestone", "state"],
+  render(node) {
+    const attrs = node.attrs;
+    const frontmatter = {
+      _type: "github.Issue",
+      _id: node.id
+    };
+    const addIfDefined = (key, value) => {
+      if (value !== void 0 && value !== null) {
+        frontmatter[key] = value;
+      }
+    };
+    addIfDefined("number", attrs["number"]);
+    addIfDefined("title", attrs["title"]);
+    addIfDefined("state", attrs["state"]);
+    addIfDefined("url", attrs["url"]);
+    addIfDefined("labels", attrs["labels"]);
+    addIfDefined("assignee", attrs["assignee"]);
+    addIfDefined("milestone", attrs["milestone"]);
+    addIfDefined("created_at", attrs["created_at"]);
+    addIfDefined("updated_at", attrs["updated_at"]);
+    if (attrs["syncedAt"]) {
+      frontmatter["_synced"] = new Date(attrs["syncedAt"]).toISOString();
+    }
+    const body = attrs["body"] ?? "";
+    return matter2.stringify(body, frontmatter);
+  },
+  parse(content) {
+    const { data, content: body } = matter2(content);
+    const attrs = {};
+    if (data["title"]) attrs["title"] = data["title"];
+    if (data["state"]) attrs["state"] = data["state"];
+    if (data["labels"]) attrs["labels"] = data["labels"];
+    if (data["assignee"]) attrs["assignee"] = data["assignee"];
+    if (data["milestone"]) attrs["milestone"] = data["milestone"];
+    return {
+      attrs,
+      body: body.trim()
+    };
+  }
+};
+
+// src/providers.ts
+init_esm_shims();
+
+// src/providers/github/index.ts
+init_esm_shims();
+function createGitHubProvider(config) {
+  const token = config.token ?? process.env["GITHUB_TOKEN"];
+  async function fetchWithAuth(url, options = {}) {
+    const headers = new Headers(options.headers);
+    if (token) {
+      headers.set("Authorization", `Bearer ${token}`);
+    }
+    headers.set("Accept", "application/vnd.github.v3+json");
+    return fetch(url, { ...options, headers });
+  }
+  function issueToNode(owner, name, issue) {
+    const nodeId = `github:${owner}/${name}#${issue.number}`;
+    return {
+      id: nodeId,
+      type: "github.Issue",
+      attrs: {
+        number: issue.number,
+        title: issue.title,
+        body: issue.body,
+        state: issue.state,
+        labels: issue.labels.map((l) => l.name),
+        assignee: issue.assignee?.login,
+        milestone: issue.milestone?.title,
+        created_at: issue.created_at,
+        updated_at: issue.updated_at,
+        url: issue.html_url,
+        repository: `${owner}/${name}`
+      }
+    };
+  }
+  return {
+    name: "github",
+    nodeTypes: [
+      "github.Issue",
+      "github.Label",
+      "github.User",
+      "github.Milestone",
+      "github.Repository"
+    ],
+    edgeTypes: [
+      "github.ASSIGNED_TO",
+      "github.HAS_LABEL",
+      "github.REFERENCES",
+      "github.BELONGS_TO"
+    ],
+    async fetch(request) {
+      const nodes = [];
+      const edges = [];
+      let cursor = request.cursor;
+      let hasMore = false;
+      const repos = config.repos ?? [];
+      if (config.orgs) {
+        for (const org of config.orgs) {
+          const response = await fetchWithAuth(
+            `https://api.github.com/orgs/${org}/repos`
+          );
+          if (response.ok) {
+            const data = await response.json();
+            repos.push(...data.map((r) => r.full_name));
+          }
+        }
+      }
+      for (const repo of repos) {
+        const [owner, name] = repo.split("/");
+        if (!owner || !name) continue;
+        const issuesUrl = `https://api.github.com/repos/${owner}/${name}/issues?state=all&per_page=100${cursor ? `&page=${cursor}` : ""}`;
+        const response = await fetchWithAuth(issuesUrl);
+        if (!response.ok) continue;
+        const etag = response.headers.get("ETag");
+        const data = await response.json();
+        for (const issue of data) {
+          if (issue.pull_request) continue;
+          const node = issueToNode(owner, name, issue);
+          nodes.push(node);
+          if (issue.assignee) {
+            edges.push({
+              type: "github.ASSIGNED_TO",
+              fromId: node.id,
+              toId: `github:user:${issue.assignee.login}`
+            });
+          }
+          for (const label of issue.labels) {
+            edges.push({
+              type: "github.HAS_LABEL",
+              fromId: node.id,
+              toId: `github:label:${owner}/${name}:${label.name}`
+            });
+          }
+        }
+        const linkHeader = response.headers.get("Link");
+        if (linkHeader?.includes('rel="next"')) {
+          hasMore = true;
+          const match = linkHeader.match(/page=(\d+)>; rel="next"/);
+          if (match) cursor = match[1];
+        }
+      }
+      return { nodes, edges, cursor, hasMore, versionToken: null };
+    },
+    async push(node, changes) {
+      if (node.type !== "github.Issue") {
+        return { success: false, error: "Only issues are pushable" };
+      }
+      const match = node.id.match(/^github:([^#]+)#(\d+)$/);
+      if (!match) {
+        return { success: false, error: "Invalid node ID format" };
+      }
+      const [, repo, number] = match;
+      const body = {};
+      for (const change of changes) {
+        if (change.field === "title") body.title = change.newValue;
+        if (change.field === "body") body.body = change.newValue;
+        if (change.field === "state") body.state = change.newValue;
+        if (change.field === "labels") body.labels = change.newValue;
+        if (change.field === "assignee") body.assignees = [change.newValue];
+        if (change.field === "milestone") body.milestone = change.newValue;
+      }
+      const response = await fetchWithAuth(
+        `https://api.github.com/repos/${repo}/issues/${number}`,
+        {
+          method: "PATCH",
+          body: JSON.stringify(body),
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+      if (!response.ok) {
+        const error = await response.text();
+        return { success: false, error };
+      }
+      return { success: true };
+    },
+    async fetchNode(nodeId) {
+      const match = nodeId.match(/^github:([^/]+)\/([^#]+)#(\d+)$/);
+      if (!match) return null;
+      const [, owner, repo, number] = match;
+      if (!owner || !repo || !number) return null;
+      const response = await fetchWithAuth(
+        `https://api.github.com/repos/${owner}/${repo}/issues/${number}`
+      );
+      if (response.status === 404) return null;
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(error);
+      }
+      const issue = await response.json();
+      if (issue.pull_request) return null;
+      return issueToNode(owner, repo, issue);
+    },
+    getTools() {
+      return [
+        {
+          name: "github.updateIssue",
+          description: "Update issue title, body, state"
+        },
+        { name: "github.addLabels", description: "Add labels to an issue" },
+        {
+          name: "github.removeLabels",
+          description: "Remove labels from an issue"
+        },
+        { name: "github.assignIssue", description: "Assign users to an issue" },
+        {
+          name: "github.createComment",
+          description: "Create a comment on an issue"
+        }
+      ];
+    }
+  };
+}
+registerProvider(
+  "github",
+  (config) => createGitHubProvider(config)
+);
+
+// src/providers/a2a/index.ts
+init_esm_shims();
+function createA2AProvider(config) {
+  return {
+    name: "a2a",
+    nodeTypes: ["a2a.Task", "a2a.Session", "a2a.Agent"],
+    edgeTypes: ["a2a.TRACKS", "a2a.CREATED_BY", "a2a.PART_OF"],
+    async fetch(request) {
+      const nodes = [];
+      const edges = [];
+      if (!config.endpoint) {
+        return { nodes, edges, hasMore: false };
+      }
+      try {
+        const response = await fetch(`${config.endpoint}/tasks`, {
+          headers: { Accept: "application/json" }
+        });
+        if (!response.ok) {
+          return { nodes, edges, hasMore: false };
+        }
+        const tasks = await response.json();
+        for (const task of tasks) {
+          const nodeId = `a2a:${task.id}`;
+          nodes.push({
+            id: nodeId,
+            type: "a2a.Task",
+            attrs: {
+              name: task.name,
+              status: task.status,
+              description: task.description,
+              created_at: task.created_at,
+              updated_at: task.updated_at,
+              meta: task.meta
+            }
+          });
+          if (task.meta?.github?.issue_number && task.meta?.github?.repository) {
+            edges.push({
+              type: "a2a.TRACKS",
+              fromId: nodeId,
+              toId: `github:${task.meta.github.repository}#${task.meta.github.issue_number}`
+            });
+          }
+          if (task.agent_id) {
+            edges.push({
+              type: "a2a.CREATED_BY",
+              fromId: nodeId,
+              toId: `a2a:agent:${task.agent_id}`
+            });
+          }
+          if (task.session_id) {
+            edges.push({
+              type: "a2a.PART_OF",
+              fromId: nodeId,
+              toId: `a2a:session:${task.session_id}`
+            });
+          }
+        }
+      } catch {
+      }
+      return { nodes, edges, hasMore: false };
+    },
+    async push(node, changes) {
+      if (!config.endpoint) {
+        return { success: false, error: "No A2A endpoint configured" };
+      }
+      const match = node.id.match(/^a2a:(.+)$/);
+      if (!match) {
+        return { success: false, error: "Invalid A2A node ID" };
+      }
+      const taskId = match[1];
+      const body = {};
+      for (const change of changes) {
+        body[change.field] = change.newValue;
+      }
+      try {
+        const response = await fetch(`${config.endpoint}/tasks/${taskId}`, {
+          method: "PATCH",
+          body: JSON.stringify(body),
+          headers: { "Content-Type": "application/json" }
+        });
+        if (!response.ok) {
+          return { success: false, error: await response.text() };
+        }
+        return { success: true };
+      } catch (err) {
+        return { success: false, error: String(err) };
+      }
+    },
+    async fetchNode(_nodeId) {
+      return null;
+    },
+    getTools() {
+      return [
+        { name: "a2a.createTask", description: "Create a new agent task" },
+        {
+          name: "a2a.updateTask",
+          description: "Update task status or metadata"
+        },
+        { name: "a2a.linkIssue", description: "Link task to GitHub issue" }
+      ];
+    }
+  };
+}
+registerProvider("a2a", (config) => createA2AProvider(config));
+
+// src/providers/git/index.ts
+init_esm_shims();
+import { exec } from "child_process";
+import { promisify } from "util";
+import { readFile as readFile3, access as access2 } from "fs/promises";
+import { join as join3 } from "path";
+var execAsync = promisify(exec);
+async function execGit(cwd, ...args) {
+  const { stdout } = await execAsync(`git ${args.join(" ")}`, { cwd });
+  return stdout.trim();
+}
+async function getWorktrees(repoPath) {
+  const output = await execGit(repoPath, "worktree", "list", "--porcelain");
+  const worktrees = [];
+  let current = {};
+  for (const line of output.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      if (current.path) worktrees.push(current);
+      current = { path: line.slice(9) };
+    } else if (line.startsWith("HEAD ")) {
+      current.head = line.slice(5);
+    } else if (line.startsWith("branch ")) {
+      current.branch = line.slice(7).replace("refs/heads/", "");
+    } else if (line === "bare") {
+      current.bare = true;
+    } else if (line === "detached") {
+      current.detached = true;
+    }
+  }
+  if (current.path) worktrees.push(current);
+  return worktrees;
+}
+async function getBranches(repoPath) {
+  try {
+    const output = await execGit(
+      repoPath,
+      "branch",
+      "-a",
+      "--format=%(refname:short)"
+    );
+    return output.split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function readWorktreeMeta(path2) {
+  const metaPath = join3(path2, ".a2a", "session.json");
+  try {
+    await access2(metaPath);
+    const content = await readFile3(metaPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function createGitProvider(config) {
+  return {
+    name: "git",
+    nodeTypes: ["git.Branch", "git.Worktree", "git.Commit"],
+    edgeTypes: ["git.TRACKS", "git.CONTAINS", "git.WORKTREE_OF"],
+    async fetch(request) {
+      const nodes = [];
+      const edges = [];
+      for (const repoConfig of config.repositories ?? []) {
+        const repoPath = repoConfig.path.replace(
+          /^~/,
+          process.env["HOME"] ?? ""
+        );
+        try {
+          const head = await execGit(repoPath, "rev-parse", "HEAD");
+          if (request.versionToken === head) {
+            return {
+              nodes,
+              edges,
+              hasMore: false,
+              cached: true,
+              versionToken: head
+            };
+          }
+          const worktrees = await getWorktrees(repoPath);
+          const branches = await getBranches(repoPath);
+          for (const wt of worktrees) {
+            const nodeId = `git:worktree:${wt.path}`;
+            const meta = await readWorktreeMeta(wt.path);
+            nodes.push({
+              id: nodeId,
+              type: "git.Worktree",
+              attrs: {
+                path: wt.path,
+                branch: wt.branch,
+                head: wt.head,
+                bare: wt.bare,
+                detached: wt.detached,
+                meta
+              }
+            });
+            if (wt.branch) {
+              edges.push({
+                type: "git.WORKTREE_OF",
+                fromId: `git:branch:${repoPath}:${wt.branch}`,
+                toId: nodeId
+              });
+            }
+          }
+          for (const branch of branches) {
+            const branchNodeId = `git:branch:${repoPath}:${branch}`;
+            const worktree = worktrees.find((wt) => wt.branch === branch);
+            nodes.push({
+              id: branchNodeId,
+              type: "git.Branch",
+              attrs: {
+                name: branch,
+                repository: repoPath,
+                worktreePath: worktree?.path
+              }
+            });
+            if (config.links) {
+              for (const link of config.links) {
+                if (link.edge === "git.TRACKS" && worktree) {
+                  const meta = await readWorktreeMeta(worktree.path);
+                  if (meta?.a2a && typeof meta.a2a === "object") {
+                    const a2aMeta = meta.a2a;
+                    if (a2aMeta["task_id"]) {
+                      edges.push({
+                        type: "git.TRACKS",
+                        fromId: branchNodeId,
+                        toId: `a2a:${a2aMeta["task_id"]}`
+                      });
+                    }
+                  }
+                }
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      return { nodes, edges, hasMore: false };
+    },
+    async push(node, changes) {
+      return { success: false, error: "Git push not implemented via provider" };
+    },
+    async fetchNode(_nodeId) {
+      return null;
+    },
+    getTools() {
+      return [
+        { name: "git.checkout", description: "Checkout branch" },
+        { name: "git.push", description: "Push changes" },
+        { name: "git.createBranch", description: "Create new branch" },
+        {
+          name: "git.createWorktree",
+          description: "Create worktree for branch"
+        }
+      ];
+    }
+  };
+}
+registerProvider("git", (config) => createGitProvider(config));
+
+// src/hardcopy/core.ts
+init_esm_shims();
+import { join as join5 } from "path";
+import { mkdir as mkdir3 } from "fs/promises";
+init_crdt();
+
+// src/conflict-store.ts
+init_esm_shims();
+import { mkdir as mkdir2, readFile as readFile4, readdir, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { join as join4 } from "path";
+import matter3 from "gray-matter";
+
+// src/conflict.ts
+init_esm_shims();
+function detectFieldConflict(field, state) {
+  const localChanged = !valuesEqual(state.local, state.base);
+  const remoteChanged = !valuesEqual(state.remote, state.base);
+  let status2;
+  if (!localChanged && !remoteChanged) {
+    status2 = "clean" /* CLEAN */;
+  } else if (localChanged && !remoteChanged) {
+    status2 = "clean" /* CLEAN */;
+  } else if (!localChanged && remoteChanged) {
+    status2 = "remote" /* REMOTE_ONLY */;
+  } else if (valuesEqual(state.local, state.remote)) {
+    status2 = "clean" /* CLEAN */;
+  } else {
+    status2 = "diverged" /* DIVERGED */;
+  }
+  return {
+    field,
+    status: status2,
+    base: state.base,
+    local: state.local,
+    remote: state.remote,
+    canAutoMerge: isListField(state)
+  };
+}
+function detectConflicts(baseNode, localParsed, remoteNode, editableFields) {
+  const conflicts = [];
+  const baseAttrs = baseNode.attrs;
+  const remoteAttrs = remoteNode.attrs;
+  for (const field of editableFields) {
+    const state = field === "body" ? {
+      base: baseAttrs["body"] ?? "",
+      local: localParsed.body ?? "",
+      remote: remoteAttrs["body"] ?? ""
+    } : {
+      base: baseAttrs[field],
+      local: localParsed.attrs[field],
+      remote: remoteAttrs[field]
+    };
+    conflicts.push(detectFieldConflict(field, state));
+  }
+  return conflicts;
+}
+function hasUnresolvableConflicts(conflicts) {
+  return conflicts.some(
+    (conflict) => conflict.status === "diverged" /* DIVERGED */ && !conflict.canAutoMerge
+  );
+}
+function autoMergeField(conflict) {
+  if (conflict.status !== "diverged" /* DIVERGED */ || !conflict.canAutoMerge) {
+    return null;
+  }
+  const merged = uniqueList([
+    ...Array.isArray(conflict.base) ? conflict.base : [],
+    ...Array.isArray(conflict.local) ? conflict.local : [],
+    ...Array.isArray(conflict.remote) ? conflict.remote : []
+  ]);
+  return merged;
+}
+function generateConflictMarkers(conflict) {
+  const local = String(conflict.local ?? "");
+  const base = String(conflict.base ?? "");
+  const remote = String(conflict.remote ?? "");
+  return `<<<<<<< LOCAL
+${local}
+||||||| BASE
+${base}
+=======
+${remote}
+>>>>>>> REMOTE`;
+}
+function parseConflictMarkers(text) {
+  const match = text.match(
+    /<<<<<<< LOCAL\r?\n([\s\S]*?)\r?\n\|\|\|\|\|\|\| BASE\r?\n([\s\S]*?)\r?\n=======\r?\n([\s\S]*?)\r?\n>>>>>>> REMOTE/
+  );
+  if (!match) return null;
+  return {
+    local: match[1] ?? "",
+    base: match[2] ?? "",
+    remote: match[3] ?? ""
+  };
+}
+function valuesEqual(a, b) {
+  if (a === b) return true;
+  if (a == null && b == null) return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    const normalizedA = normalizeArray(a);
+    const normalizedB = normalizeArray(b);
+    if (normalizedA.length !== normalizedB.length) return false;
+    return normalizedA.every((value, index) => value === normalizedB[index]);
+  }
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function normalizeArray(values) {
+  return values.map((value) => JSON.stringify(value)).sort();
+}
+function isListField(state) {
+  return Array.isArray(state.base) || Array.isArray(state.local) || Array.isArray(state.remote);
+}
+function uniqueList(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const value of values) {
+    const key = JSON.stringify(value);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(value);
+  }
+  return result;
+}
+
+// src/conflict-store.ts
+var ConflictStore = class {
+  conflictsDir;
+  constructor(conflictsDir) {
+    this.conflictsDir = conflictsDir;
+  }
+  async save(info) {
+    await mkdir2(this.conflictsDir, { recursive: true });
+    const filePath = this.getPath(info.nodeId);
+    const body = formatConflictBody(info.fields);
+    const frontmatter = {
+      nodeId: info.nodeId,
+      nodeType: info.nodeType,
+      filePath: info.filePath,
+      detectedAt: new Date(info.detectedAt).toISOString(),
+      fields: info.fields.map((field) => ({
+        field: field.field,
+        status: field.status,
+        canAutoMerge: field.canAutoMerge
+      }))
+    };
+    await writeFile2(filePath, matter3.stringify(body, frontmatter));
+  }
+  async list() {
+    const entries = await readdir(this.conflictsDir).catch(() => []);
+    const conflicts = [];
+    for (const entry of entries) {
+      if (!entry.endsWith(".md")) continue;
+      const fullPath = join4(this.conflictsDir, entry);
+      try {
+        const content = await readFile4(fullPath, "utf-8");
+        const parsed = matter3(content);
+        const data = parsed.data;
+        const fields = parseStoredFields(data["fields"]);
+        const detectedAt = Date.parse(String(data["detectedAt"] ?? ""));
+        conflicts.push({
+          nodeId: String(data["nodeId"] ?? ""),
+          nodeType: String(data["nodeType"] ?? ""),
+          filePath: String(data["filePath"] ?? ""),
+          detectedAt: Number.isNaN(detectedAt) ? 0 : detectedAt,
+          fields
+        });
+      } catch {
+        continue;
+      }
+    }
+    return conflicts.filter((conflict) => conflict.nodeId.length > 0);
+  }
+  async get(nodeId) {
+    const result = await this.read(nodeId);
+    return result?.info ?? null;
+  }
+  async read(nodeId) {
+    const filePath = this.getPath(nodeId);
+    try {
+      const content = await readFile4(filePath, "utf-8");
+      const parsed = matter3(content);
+      const data = parsed.data;
+      const fields = parseStoredFields(data["fields"]);
+      const detectedAt = Date.parse(String(data["detectedAt"] ?? ""));
+      const info = {
+        nodeId: String(data["nodeId"] ?? nodeId),
+        nodeType: String(data["nodeType"] ?? ""),
+        filePath: String(data["filePath"] ?? ""),
+        detectedAt: Number.isNaN(detectedAt) ? 0 : detectedAt,
+        fields
+      };
+      return { info, body: parsed.content };
+    } catch {
+      return null;
+    }
+  }
+  async remove(nodeId) {
+    const filePath = this.getPath(nodeId);
+    try {
+      await rm2(filePath, { force: true });
+    } catch {
+      return;
+    }
+  }
+  getPath(nodeId) {
+    return join4(this.conflictsDir, `${encodeURIComponent(nodeId)}.md`);
+  }
+  getArtifactPath(nodeId) {
+    return this.getPath(nodeId);
+  }
+};
+function parseStoredFields(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => {
+    if (!item || typeof item !== "object") return null;
+    const record = item;
+    const field = String(record["field"] ?? "");
+    if (!field) return null;
+    return {
+      field,
+      status: String(record["status"] ?? "clean"),
+      canAutoMerge: Boolean(record["canAutoMerge"]),
+      base: null,
+      local: null,
+      remote: null
+    };
+  }).filter((item) => item !== null);
+}
+function formatConflictBody(fields) {
+  const blocks = fields.filter((field) => field.status === "diverged").map((field) => `## ${field.field}
+${generateConflictMarkers(field)}`);
+  return blocks.join("\n\n");
+}
+
+// src/env.ts
+init_esm_shims();
+import { readFile as readFile5 } from "fs/promises";
+async function loadEnvFile(path2) {
+  let content;
+  try {
+    content = await readFile5(path2, "utf-8");
+  } catch {
+    return;
+  }
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const index = line.indexOf("=");
+    if (index <= 0) continue;
+    const key = line.slice(0, index).trim();
+    const rawValue = line.slice(index + 1).trim();
+    if (!key) continue;
+    if (process.env[key] !== void 0) continue;
+    process.env[key] = stripQuotes(rawValue);
+  }
+}
+function stripQuotes(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+// src/hardcopy/core.ts
+var Hardcopy = class {
+  root;
+  dataDir;
+  _db = null;
+  _crdt = null;
+  _config = null;
+  _providers = /* @__PURE__ */ new Map();
+  _conflictStore = null;
+  constructor(options) {
+    this.root = options.root;
+    this.dataDir = join5(options.root, ".hardcopy");
+  }
+  async initialize() {
+    await mkdir3(this.dataDir, { recursive: true });
+    await loadEnvFile(join5(this.dataDir, ".env"));
+    await mkdir3(join5(this.dataDir, "crdt"), { recursive: true });
+    this._db = await HardcopyDatabase.open(join5(this.dataDir, "db.sqlite"));
+    this._crdt = new CRDTStore(join5(this.dataDir, "crdt"));
+  }
+  async loadConfig() {
+    if (this._config) return this._config;
+    const configPath = join5(this.root, "hardcopy.yaml");
+    this._config = await loadConfig(configPath);
+    await this.initializeProviders();
+    return this._config;
+  }
+  async initializeProviders() {
+    if (!this._config) return;
+    for (const source of this._config.sources) {
+      const factory = getProvider(source.provider);
+      if (factory) {
+        this._providers.set(source.name, factory(source));
+      }
+    }
+  }
+  getDatabase() {
+    if (!this._db) throw new Error("Database not initialized");
+    return this._db;
+  }
+  getCRDTStore() {
+    if (!this._crdt) throw new Error("CRDT store not initialized");
+    return this._crdt;
+  }
+  getConflictStore() {
+    if (!this._conflictStore) {
+      this._conflictStore = new ConflictStore(join5(this.dataDir, "conflicts"));
+    }
+    return this._conflictStore;
+  }
+  getProviders() {
+    return this._providers;
+  }
+  async close() {
+    if (this._db) {
+      await this._db.close();
+      this._db = null;
+    }
+  }
+};
+
+// src/hardcopy/sync.ts
+init_esm_shims();
+async function sync() {
+  const config = await this.loadConfig();
+  const db = this.getDatabase();
+  const providers2 = this.getProviders();
+  const stats = { nodes: 0, edges: 0, errors: [] };
+  for (const source of config.sources) {
+    const provider = providers2.get(source.name);
+    if (!provider) {
+      stats.errors.push(`Provider not found: ${source.provider}`);
+      continue;
+    }
+    try {
+      const result = await provider.fetch({ query: {} });
+      if (!result.cached) {
+        await db.upsertNodes(
+          result.nodes.map((n) => ({
+            ...n,
+            syncedAt: Date.now(),
+            versionToken: result.versionToken ?? void 0
+          }))
+        );
+        await db.upsertEdges(result.edges);
+        stats.nodes += result.nodes.length;
+        stats.edges += result.edges.length;
+      }
+    } catch (err) {
+      stats.errors.push(`Error syncing ${source.name}: ${err}`);
+    }
+  }
+  return stats;
+}
+
+// src/hardcopy/index.ts
+init_views();
+init_diff();
+
+// src/hardcopy/push.ts
+init_esm_shims();
+init_crdt();
+import { join as join9 } from "path";
+import { readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
+import matter4 from "gray-matter";
+
+// src/merge.ts
+init_esm_shims();
+import { mkdtemp, rm as rm4, writeFile as writeFile4, mkdir as mkdir5 } from "fs/promises";
+import { join as join8 } from "path";
+import { tmpdir } from "os";
+import { spawnSync } from "child_process";
+
+// src/llm-merge.ts
+init_esm_shims();
+var MERGE_SYSTEM_PROMPT = `You are a precise text merge assistant. Your task is to intelligently merge two versions of text that have both been modified from a common base.
+
+Rules:
+1. Preserve ALL meaningful changes from both versions
+2. When both versions change the same content differently, combine the intents (e.g., if one adds bold and one restructures, do both)
+3. Never lose information - if text was added on either side, include it
+4. Maintain consistent formatting and style
+5. Output ONLY the merged text, no explanations or markdown code blocks`;
+async function llmMergeText(base, local, remote, options = {}) {
+  const baseURL = options.baseURL ?? process.env.OPENAI_BASE_URL ?? "http://localhost:6433";
+  const model = options.model ?? process.env.OPENAI_MODEL ?? "gpt-4o";
+  const apiKey = options.apiKey ?? process.env.OPENAI_API_KEY;
+  const temperature = options.temperature ?? 0;
+  const messages = [
+    { role: "system", content: MERGE_SYSTEM_PROMPT },
+    {
+      role: "user",
+      content: `Merge these two versions that diverged from a common base.
+
+=== BASE (original) ===
+${base}
+
+=== LOCAL (my changes) ===
+${local}
+
+=== REMOTE (their changes) ===
+${remote}
+
+=== MERGED OUTPUT ===`
+    }
+  ];
+  try {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (apiKey) {
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    const response = await fetch(`${baseURL}/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        model,
+        messages,
+        temperature,
+        max_tokens: 4096
+      })
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    return data.choices?.[0]?.message?.content ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/merge.ts
+async function mergeText(base, local, remote, options) {
+  if (local === remote) return local;
+  if (local === base) return remote;
+  if (remote === base) return local;
+  const diff3Result = await tryDiff3Merge(base, local, remote, options.tempDir);
+  if (diff3Result !== null) {
+    return diff3Result;
+  }
+  return llmMergeText(base, local, remote, options.llmOptions);
+}
+async function tryDiff3Merge(base, local, remote, tempDir) {
+  const root = tempDir ?? join8(tmpdir(), "hardcopy-merge");
+  await mkdir5(root, { recursive: true });
+  const runDir = await mkdtemp(join8(root, "merge-"));
+  const basePath = join8(runDir, "base");
+  const localPath = join8(runDir, "local");
+  const remotePath = join8(runDir, "remote");
+  try {
+    await writeFile4(basePath, base);
+    await writeFile4(localPath, local);
+    await writeFile4(remotePath, remote);
+    const result = spawnSync("diff3", ["-m", localPath, basePath, remotePath], {
+      encoding: "utf-8"
+    });
+    if (result.status === 0 && typeof result.stdout === "string") {
+      return result.stdout;
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    await rm4(runDir, { recursive: true, force: true });
+  }
+}
+
+// src/hardcopy/push.ts
+init_format();
+init_diff();
+init_diff();
+async function push(filePath, options = {}) {
+  await this.loadConfig();
+  const db = this.getDatabase();
+  const crdt = this.getCRDTStore();
+  const stats = {
+    pushed: 0,
+    skipped: 0,
+    conflicts: 0,
+    errors: []
+  };
+  const diffs = await diff.call(this, filePath);
+  for (const diffResult of diffs) {
+    if (diffResult.changes.length === 0) {
+      stats.skipped++;
+      continue;
+    }
+    const provider = findProviderForNode.call(this, diffResult.nodeId);
+    if (!provider) {
+      stats.errors.push(`No provider for ${diffResult.nodeId}`);
+      continue;
+    }
+    const dbNode = await db.getNode(diffResult.nodeId);
+    if (!dbNode) {
+      stats.errors.push(`Node not found: ${diffResult.nodeId}`);
+      continue;
+    }
+    const format = getFormat(dbNode.type);
+    if (!format) {
+      stats.errors.push(`No format for ${dbNode.type}`);
+      continue;
+    }
+    try {
+      const localParsed = await parseLocalFile(diffResult.filePath);
+      if (!localParsed) {
+        stats.errors.push(`Failed to parse ${diffResult.filePath}`);
+        continue;
+      }
+      const remoteNode = await provider.fetchNode(diffResult.nodeId);
+      let changes = diffResult.changes;
+      if (remoteNode && !options.force) {
+        let conflicts = detectConflicts(
+          dbNode,
+          localParsed,
+          remoteNode,
+          format.editableFields
+        );
+        const semanticMerges = await trySemanticMerges.call(
+          this,
+          conflicts,
+          diffResult.filePath
+        );
+        if (semanticMerges.size > 0) {
+          changes = applySemanticMerges(changes, semanticMerges);
+          conflicts = conflicts.map(
+            (conflict) => semanticMerges.has(conflict.field) ? { ...conflict, status: "clean" /* CLEAN */ } : conflict
+          );
+        }
+        if (hasUnresolvableConflicts(conflicts)) {
+          await saveConflict.call(this, diffResult, conflicts, dbNode.type);
+          stats.conflicts++;
+          continue;
+        }
+        changes = applyAutoMerges(changes, conflicts);
+      }
+      const result = await provider.push(dbNode, changes);
+      if (result.success) {
+        const updatedAttrs = { ...dbNode.attrs };
+        for (const change of changes) {
+          updatedAttrs[change.field] = change.newValue;
+        }
+        await db.upsertNode({
+          ...dbNode,
+          attrs: updatedAttrs,
+          syncedAt: Date.now()
+        });
+        const doc = await crdt.loadOrCreate(diffResult.nodeId);
+        const bodyChange = changes.find((c) => c.field === "body");
+        if (bodyChange) {
+          setDocContent(doc, bodyChange.newValue);
+        }
+        await crdt.save(diffResult.nodeId, doc);
+        try {
+          await updateLocalFileAfterPush(diffResult.filePath, changes);
+        } catch (err) {
+          stats.errors.push(
+            `Failed to update local file ${diffResult.filePath}: ${err}`
+          );
+        }
+        stats.pushed++;
+      } else {
+        stats.errors.push(`Push failed for ${diffResult.nodeId}: ${result.error}`);
+      }
+    } catch (err) {
+      stats.errors.push(`Error pushing ${diffResult.nodeId}: ${err}`);
+    }
+  }
+  return stats;
+}
+async function status() {
+  const db = this.getDatabase();
+  const nodes = await db.queryNodes();
+  const [edges] = await Promise.all([db.getEdges()]);
+  const byType = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    byType.set(node.type, (byType.get(node.type) ?? 0) + 1);
+  }
+  const { getChangedFiles: getChangedFiles2 } = await Promise.resolve().then(() => (init_diff(), diff_exports));
+  const changedFiles = await getChangedFiles2.call(this);
+  const conflicts = await listConflicts.call(this);
+  return {
+    totalNodes: nodes.length,
+    totalEdges: edges.length,
+    nodesByType: Object.fromEntries(byType),
+    changedFiles,
+    conflicts
+  };
+}
+async function listConflicts() {
+  return this.getConflictStore().list();
+}
+async function getConflict(nodeId) {
+  return this.getConflictStore().get(nodeId);
+}
+async function getConflictDetail(nodeId) {
+  const store = this.getConflictStore();
+  const detail = await store.read(nodeId);
+  if (!detail) return null;
+  return {
+    info: detail.info,
+    body: detail.body,
+    artifactPath: store.getArtifactPath(nodeId)
+  };
+}
+async function resolveConflict(nodeId, resolution) {
+  const store = this.getConflictStore();
+  const conflict = await store.read(nodeId);
+  if (!conflict) throw new Error(`Conflict not found: ${nodeId}`);
+  const db = this.getDatabase();
+  const dbNode = await db.getNode(nodeId);
+  if (!dbNode) throw new Error(`Node not found: ${nodeId}`);
+  const provider = findProviderForNode.call(this, nodeId);
+  if (!provider) throw new Error(`No provider for ${nodeId}`);
+  const format = getFormat(dbNode.type);
+  if (!format) throw new Error(`No format for ${dbNode.type}`);
+  const blocks = parseConflictBlocks(conflict.body);
+  if (blocks.size === 0) {
+    throw new Error(`No conflict markers found for ${nodeId}`);
+  }
+  const fileContent = await readFile8(conflict.info.filePath, "utf-8");
+  const parsed = matter4(fileContent);
+  const attrs = parsed.data;
+  let body = parsed.content.trim();
+  const updatedAttrs = { ...dbNode.attrs };
+  for (const [field, choice] of Object.entries(resolution)) {
+    const block = blocks.get(field);
+    if (!block) continue;
+    const value = choice === "local" ? block.local : block.remote;
+    if (field === "body") {
+      body = value;
+      updatedAttrs["body"] = value;
+    } else {
+      attrs[field] = value;
+      updatedAttrs[field] = value;
+    }
+  }
+  const nextContent = matter4.stringify(body, attrs);
+  await writeFile5(conflict.info.filePath, nextContent);
+  const parsedForChanges = { attrs, body };
+  const changes = detectChanges(
+    parsedForChanges,
+    dbNode,
+    format.editableFields
+  );
+  if (changes.length > 0) {
+    const result = await provider.push(dbNode, changes);
+    if (!result.success) {
+      throw new Error(`Push failed for ${nodeId}: ${result.error}`);
+    }
+  }
+  await db.upsertNode({
+    ...dbNode,
+    attrs: updatedAttrs,
+    syncedAt: Date.now()
+  });
+  const crdt = this.getCRDTStore();
+  const doc = await crdt.loadOrCreate(nodeId);
+  if (updatedAttrs["body"] !== void 0) {
+    setDocContent(doc, String(updatedAttrs["body"] ?? ""));
+  }
+  await crdt.save(nodeId, doc);
+  await store.remove(nodeId);
+}
+function findProviderForNode(nodeId) {
+  const [providerPrefix] = nodeId.split(":");
+  for (const [, provider] of this.getProviders()) {
+    if (provider.name === providerPrefix) return provider;
+  }
+  return void 0;
+}
+async function parseLocalFile(fullPath) {
+  try {
+    const content = await readFile8(fullPath, "utf-8");
+    return parseFile(content, "generic");
+  } catch {
+    return null;
+  }
+}
+async function updateLocalFileAfterPush(fullPath, changes) {
+  const content = await readFile8(fullPath, "utf-8");
+  const parsed = matter4(content);
+  const attrs = parsed.data;
+  let body = parsed.content;
+  for (const change of changes) {
+    if (change.field === "body") {
+      body = String(change.newValue ?? "");
+      continue;
+    }
+    if (change.newValue === void 0 || change.newValue === null) {
+      delete attrs[change.field];
+    } else {
+      attrs[change.field] = change.newValue;
+    }
+  }
+  const nextContent = matter4.stringify(body, attrs);
+  await writeFile5(fullPath, nextContent);
+}
+async function saveConflict(diffResult, conflicts, nodeType) {
+  const store = this.getConflictStore();
+  await store.save({
+    nodeId: diffResult.nodeId,
+    nodeType,
+    filePath: diffResult.filePath,
+    detectedAt: Date.now(),
+    fields: conflicts
+  });
+}
+function applyAutoMerges(changes, conflicts) {
+  const mergedByField = /* @__PURE__ */ new Map();
+  for (const conflict of conflicts) {
+    const merged = autoMergeField(conflict);
+    if (merged !== null) {
+      mergedByField.set(conflict.field, merged);
+    }
+  }
+  if (mergedByField.size === 0) return changes;
+  const mergedChanges = changes.map((change) => {
+    if (!mergedByField.has(change.field)) return change;
+    return {
+      ...change,
+      newValue: mergedByField.get(change.field)
+    };
+  });
+  for (const [field, value] of mergedByField) {
+    if (!mergedChanges.find((change) => change.field === field)) {
+      mergedChanges.push({ field, oldValue: void 0, newValue: value });
+    }
+  }
+  return mergedChanges;
+}
+async function trySemanticMerges(conflicts, filePath) {
+  const result = /* @__PURE__ */ new Map();
+  const bodyConflict = conflicts.find(
+    (conflict) => conflict.field === "body" && conflict.status === "diverged" /* DIVERGED */ && !conflict.canAutoMerge
+  );
+  if (!bodyConflict) return result;
+  const base = String(bodyConflict.base ?? "");
+  const local = String(bodyConflict.local ?? "");
+  const remote = String(bodyConflict.remote ?? "");
+  const merged = await mergeText(base, local, remote, {
+    tempDir: join9(this.dataDir, "tmp", "merge"),
+    filePath,
+    llmOptions: {
+      baseURL: process.env.OPENAI_BASE_URL,
+      model: process.env.OPENAI_MODEL,
+      apiKey: process.env.OPENAI_API_KEY
+    }
+  });
+  if (merged !== null) {
+    result.set("body", merged);
+  }
+  return result;
+}
+function applySemanticMerges(changes, merged) {
+  if (merged.size === 0) return changes;
+  const next = changes.map((change) => {
+    if (!merged.has(change.field)) return change;
+    return { ...change, newValue: merged.get(change.field) };
+  });
+  for (const [field, value] of merged) {
+    if (!next.find((change) => change.field === field)) {
+      next.push({ field, oldValue: void 0, newValue: value });
+    }
+  }
+  return next;
+}
+function parseConflictBlocks(content) {
+  const blocks = /* @__PURE__ */ new Map();
+  const regex = /^\s*##\s+(.+?)\r?\n([\s\S]*?)(?=^\s*##\s+|\s*$)/gm;
+  for (const match of content.matchAll(regex)) {
+    const field = match[1]?.trim();
+    const block = match[2] ?? "";
+    if (!field) continue;
+    const parsed = parseConflictMarkers(block);
+    if (parsed) blocks.set(field, parsed);
+  }
+  if (blocks.size === 0) {
+    const parsed = parseConflictMarkers(content);
+    if (parsed) blocks.set("body", parsed);
+  }
+  return blocks;
+}
+
+// src/hardcopy/init.ts
+init_esm_shims();
+import { join as join10 } from "path";
+import { mkdir as mkdir6, writeFile as writeFile6, access as access3 } from "fs/promises";
+async function initHardcopy(root) {
+  const dataDir = join10(root, ".hardcopy");
+  await mkdir6(dataDir, { recursive: true });
+  await mkdir6(join10(dataDir, "crdt"), { recursive: true });
+  await mkdir6(join10(dataDir, "errors"), { recursive: true });
+  const db = await HardcopyDatabase.open(join10(dataDir, "db.sqlite"));
+  await db.close();
+  const configPath = join10(root, "hardcopy.yaml");
+  try {
+    await access3(configPath);
+  } catch {
+    const defaultConfig = `# Hardcopy configuration
+sources: []
+views: []
+`;
+    await writeFile6(configPath, defaultConfig);
+  }
+}
+
+// src/hardcopy/types.ts
+init_esm_shims();
+
+// src/hardcopy/index.ts
+registerFormat(githubIssueFormat);
+Hardcopy.prototype.sync = sync;
+Hardcopy.prototype.getViews = getViews;
+Hardcopy.prototype.refreshView = refreshView;
+Hardcopy.prototype.diff = diff;
+Hardcopy.prototype.getChangedFiles = getChangedFiles;
+Hardcopy.prototype.push = push;
+Hardcopy.prototype.status = status;
+Hardcopy.prototype.listConflicts = listConflicts;
+Hardcopy.prototype.getConflict = getConflict;
+Hardcopy.prototype.getConflictDetail = getConflictDetail;
+Hardcopy.prototype.resolveConflict = resolveConflict;
+
+// src/mcp-server.ts
+init_esm_shims();
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ErrorCode,
+  ListToolsRequestSchema,
+  McpError
+} from "@modelcontextprotocol/sdk/types.js";
+function createMcpServer(root) {
+  const server = new Server(
+    { name: "hardcopy", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "hardcopy_sync",
+        description: "Sync all configured remote sources to local database",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "hardcopy_status",
+        description: "Show sync status including changed files and conflicts",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "hardcopy_refresh",
+        description: "Refresh local files from database for a view pattern",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pattern: {
+              type: "string",
+              description: "View pattern to refresh (supports glob, e.g. docs/issues)"
+            },
+            clean: {
+              type: "boolean",
+              description: "Remove files that no longer match the view",
+              default: false
+            },
+            syncFirst: {
+              type: "boolean",
+              description: "Sync data from remote before refreshing",
+              default: false
+            }
+          },
+          required: ["pattern"]
+        }
+      },
+      {
+        name: "hardcopy_diff",
+        description: "Show local changes vs synced state for files matching pattern",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pattern: {
+              type: "string",
+              description: "File pattern to check (supports glob)"
+            }
+          }
+        }
+      },
+      {
+        name: "hardcopy_push",
+        description: "Push local changes to remote sources",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pattern: {
+              type: "string",
+              description: "File pattern to push (supports glob)"
+            },
+            force: {
+              type: "boolean",
+              description: "Push even if conflicts are detected",
+              default: false
+            }
+          }
+        }
+      },
+      {
+        name: "hardcopy_conflicts",
+        description: "List all unresolved conflicts",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "hardcopy_resolve",
+        description: "Resolve a specific conflict",
+        inputSchema: {
+          type: "object",
+          properties: {
+            nodeId: {
+              type: "string",
+              description: "The node ID of the conflict to resolve"
+            },
+            resolution: {
+              type: "object",
+              description: 'Map of field names to resolution choice ("local" or "remote")',
+              additionalProperties: {
+                type: "string",
+                enum: ["local", "remote"]
+              }
+            }
+          },
+          required: ["nodeId", "resolution"]
+        }
+      }
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args = {} } = request.params;
+    const hc = new Hardcopy({ root });
+    try {
+      await hc.initialize();
+      await hc.loadConfig();
+      switch (name) {
+        case "hardcopy_sync":
+          return await handleSync(hc);
+        case "hardcopy_status":
+          return await handleStatus(hc);
+        case "hardcopy_refresh":
+          return await handleRefresh(hc, args);
+        case "hardcopy_diff":
+          return await handleDiff(hc, args);
+        case "hardcopy_push":
+          return await handlePush(hc, args);
+        case "hardcopy_conflicts":
+          return await handleConflicts(hc);
+        case "hardcopy_resolve":
+          return await handleResolve(hc, args);
+        default:
+          throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+      }
+    } catch (error) {
+      if (error instanceof McpError) throw error;
+      throw new McpError(
+        ErrorCode.InternalError,
+        `Failed to execute ${name}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    } finally {
+      await hc.close();
+    }
+  });
+  return server;
+}
+async function handleSync(hc) {
+  const stats = await hc.sync();
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            synced: { nodes: stats.nodes, edges: stats.edges },
+            errors: stats.errors
+          },
+          null,
+          2
+        )
+      }
+    ]
+  };
+}
+async function handleStatus(hc) {
+  const status2 = await hc.status();
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            nodes: status2.totalNodes,
+            edges: status2.totalEdges,
+            byType: status2.nodesByType,
+            changedFiles: status2.changedFiles.map((f) => ({
+              path: f.path,
+              status: f.status,
+              nodeId: f.nodeId
+            })),
+            conflicts: status2.conflicts.map((c) => ({
+              nodeId: c.nodeId,
+              fields: c.fields.map((f) => f.field)
+            }))
+          },
+          null,
+          2
+        )
+      }
+    ]
+  };
+}
+async function handleRefresh(hc, args) {
+  const { pattern, clean = false, syncFirst = false } = args;
+  if (syncFirst) {
+    await hc.sync();
+  }
+  const views = await hc.getViews();
+  const matching = views.filter(
+    (v) => v === pattern || v.startsWith(pattern) || pattern.includes("*")
+  );
+  if (matching.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            { error: `No views match pattern: ${pattern}`, available: views },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+  const results = [];
+  for (const view of matching) {
+    const result = await hc.refreshView(view, { clean });
+    results.push({
+      view,
+      rendered: result.rendered,
+      orphaned: result.orphaned.length,
+      cleaned: result.cleaned
+    });
+  }
+  return {
+    content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
+  };
+}
+async function handleDiff(hc, args) {
+  const diffs = await hc.diff(args.pattern);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          diffs.map((d) => ({
+            nodeId: d.nodeId,
+            nodeType: d.nodeType,
+            filePath: d.filePath,
+            changes: d.changes.map((c) => ({
+              field: c.field,
+              old: truncate(c.oldValue),
+              new: truncate(c.newValue)
+            }))
+          })),
+          null,
+          2
+        )
+      }
+    ]
+  };
+}
+async function handlePush(hc, args) {
+  const stats = await hc.push(args.pattern, { force: args.force });
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            pushed: stats.pushed,
+            skipped: stats.skipped,
+            conflicts: stats.conflicts,
+            errors: stats.errors
+          },
+          null,
+          2
+        )
+      }
+    ]
+  };
+}
+async function handleConflicts(hc) {
+  const conflicts = await hc.listConflicts();
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          conflicts.map((c) => ({
+            nodeId: c.nodeId,
+            nodeType: c.nodeType,
+            filePath: c.filePath,
+            fields: c.fields.map((f) => ({
+              field: f.field,
+              status: f.status,
+              canAutoMerge: f.canAutoMerge
+            }))
+          })),
+          null,
+          2
+        )
+      }
+    ]
+  };
+}
+async function handleResolve(hc, args) {
+  await hc.resolveConflict(args.nodeId, args.resolution);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ resolved: args.nodeId }, null, 2)
+      }
+    ]
+  };
+}
+function truncate(value, maxLen = 100) {
+  const str = typeof value === "string" ? value : JSON.stringify(value);
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen) + "...";
+}
+async function serveMcp(root) {
+  const server = createMcpServer(root);
+  const transport = new StdioServerTransport();
+  console.error("Hardcopy MCP Server running on stdio");
+  await server.connect(transport);
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  serveMcp(process.cwd()).catch((error) => {
+    console.error("Fatal error in MCP server:", error);
+    process.exit(1);
+  });
+}
+export {
+  CRDTStore,
+  ConflictStatus,
+  ConflictStore,
+  HardcopyDatabase as Database,
+  Hardcopy,
+  HardcopyDatabase,
+  autoMergeField,
+  createA2AProvider,
+  createGitHubProvider,
+  createGitProvider,
+  createMcpServer,
+  detectConflicts,
+  detectFieldConflict,
+  generateConflictMarkers,
+  getDocAttrs,
+  getDocContent,
+  getFormat,
+  getProvider,
+  hasUnresolvableConflicts,
+  initHardcopy,
+  listFormats,
+  listProviders,
+  llmMergeText,
+  loadConfig,
+  mergeText,
+  parseConfig,
+  parseConflictMarkers,
+  parseFile,
+  registerFormat,
+  registerProvider,
+  renderNode,
+  serveMcp,
+  setDocAttrs,
+  setDocContent
+};