@iqlabs-official/iq-git-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1022 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/core/repo.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { dirname, join } from "path";
+var DIR = ".iqgit";
+function findRepoRoot(cwd = process.cwd()) {
+  let dir = cwd;
+  while (true) {
+    if (existsSync(join(dir, DIR))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) {
+      throw new Error("not an iqgit repo (or any parent)");
+    }
+    dir = parent;
+  }
+}
+function initRepo(cwd) {
+  mkdirSync(join(cwd, DIR, "pending"), { recursive: true });
+}
+function readConfig(repoRoot) {
+  try {
+    return JSON.parse(readFileSync(join(repoRoot, DIR, "config.json"), "utf8"));
+  } catch {
+    return { owner: "", repo: "", isPublic: true };
+  }
+}
+function writeConfig(repoRoot, cfg) {
+  writeFileSync(join(repoRoot, DIR, "config.json"), JSON.stringify(cfg, null, 2));
+}
+function readHead(repoRoot) {
+  try {
+    return readFileSync(join(repoRoot, DIR, "HEAD"), "utf8").trim() || null;
+  } catch {
+    return null;
+  }
+}
+function writeHead(repoRoot, commitId) {
+  writeFileSync(join(repoRoot, DIR, "HEAD"), commitId);
+}
+function readIndex(repoRoot) {
+  try {
+    return JSON.parse(readFileSync(join(repoRoot, DIR, "index.json"), "utf8"));
+  } catch {
+    return [];
+  }
+}
+function writeIndex(repoRoot, paths) {
+  const sorted = Array.from(new Set(paths)).sort();
+  writeFileSync(join(repoRoot, DIR, "index.json"), JSON.stringify(sorted, null, 2));
+}
+function listPending(repoRoot) {
+  const dir = join(repoRoot, DIR, "pending");
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => {
+    const seqStr = e.name.split("-")[0];
+    if (!seqStr) throw new Error(`malformed pending dir: ${e.name}`);
+    const dirPath = join(dir, e.name);
+    return {
+      dir: dirPath,
+      seq: Number(seqStr),
+      meta: JSON.parse(readFileSync(join(dirPath, "meta.json"), "utf8"))
+    };
+  }).sort((a, b) => a.seq - b.seq);
+}
+function appendPending(repoRoot, meta, tree, blobs) {
+  const existing = listPending(repoRoot);
+  const seq = (existing[existing.length - 1]?.seq ?? 0) + 1;
+  const seqStr = String(seq).padStart(3, "0");
+  const dir = join(repoRoot, DIR, "pending", `${seqStr}-${meta.id}`);
+  mkdirSync(join(dir, "blobs"), { recursive: true });
+  writeFileSync(join(dir, "meta.json"), JSON.stringify(meta, null, 2));
+  writeFileSync(join(dir, "tree.json"), JSON.stringify(tree, null, 2));
+  for (const [hash, base64] of blobs) {
+    writeFileSync(join(dir, "blobs", hash), base64);
+  }
+  return { dir, seq, meta };
+}
+function updatePendingMeta(p, patch) {
+  const next = { ...p.meta, ...patch };
+  const target = join(p.dir, "meta.json");
+  const tmp = `${target}.tmp`;
+  writeFileSync(tmp, JSON.stringify(next, null, 2));
+  renameSync(tmp, target);
+  p.meta = next;
+}
+function readPendingTree(p) {
+  return JSON.parse(readFileSync(join(p.dir, "tree.json"), "utf8"));
+}
+function readPendingBlob(p, hash) {
+  return readFileSync(join(p.dir, "blobs", hash), "utf8");
+}
+function discardPending(p) {
+  rmSync(p.dir, { recursive: true, force: true });
+}
+var cacheMem = /* @__PURE__ */ new Map();
+function cacheGet(repoRoot, hash) {
+  return loadCache(repoRoot)[hash] ?? null;
+}
+function cacheSet(repoRoot, hash, entry) {
+  const c = loadCache(repoRoot);
+  c[hash] = entry;
+  writeFileSync(cachePath(repoRoot), JSON.stringify(c, null, 2));
+}
+function cachePath(repoRoot) {
+  return join(repoRoot, DIR, "upload-cache.json");
+}
+function loadCache(repoRoot) {
+  const cached = cacheMem.get(repoRoot);
+  if (cached) return cached;
+  let parsed = {};
+  try {
+    parsed = JSON.parse(readFileSync(cachePath(repoRoot), "utf8"));
+  } catch {
+  }
+  cacheMem.set(repoRoot, parsed);
+  return parsed;
+}
+
+// src/ui.ts
+import { confirm as inqConfirm, input as inqInput, select as inqSelect } from "@inquirer/prompts";
+import chalk from "chalk";
+import ora from "ora";
+function fail(msg) {
+  console.error(chalk.red("\u2717"), msg);
+  process.exit(1);
+}
+var log = {
+  info(msg) {
+    console.log(msg);
+  },
+  success(msg) {
+    console.log(chalk.green("\u2713"), msg);
+  },
+  warn(msg) {
+    console.log(chalk.yellow("\u26A0"), msg);
+  },
+  dim(msg) {
+    console.log(chalk.gray(msg));
+  }
+};
+function spinner(label) {
+  return ora(label);
+}
+var confirm = inqConfirm;
+var input = inqInput;
+var select = inqSelect;
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+function formatCommit(c) {
+  return `${chalk.yellow(c.id.slice(0, 7))}  ${c.message}  ${chalk.gray(timeAgo(c.timestamp))}`;
+}
+function timeAgo(ts) {
+  const s = Math.floor((Date.now() - ts) / 1e3);
+  if (s < 60) return `${s}s ago`;
+  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
+  return `${Math.floor(s / 86400)}d ago`;
+}
+
+// src/commands/init.ts
+function register(program2) {
+  program2.command("init").option("--name <name>", "repository name").option("--public", "default visibility").option("--private").action((opts) => {
+    const cwd = process.cwd();
+    if (existsSync2(join2(cwd, ".iqgit"))) fail("already an iqgit repo");
+    initRepo(cwd);
+    writeConfig(cwd, {
+      owner: "",
+      repo: opts.name ?? "",
+      isPublic: !opts.private
+    });
+    log.success("Initialized empty iqgit repo in .iqgit/");
+    log.dim("Next: iqgit create <name> [--public|--private]");
+  });
+}
+
+// src/commands/create.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+
+// src/setup.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { dirname as dirname2, join as join3 } from "path";
+import { Connection, Keypair, LAMPORTS_PER_SOL } from "@solana/web3.js";
+import iqlabs from "@iqlabs-official/solana-sdk";
+import { GitClient } from "@iqlabs-official/git-sdk/node";
+import { config as loadEnv } from "dotenv";
+var HOME_DIR = join3(homedir(), ".iq-git");
+var ENV_PATH = join3(HOME_DIR, ".env");
+var CONFIG_PATH = join3(HOME_DIR, "config.json");
+var DEFAULT_WALLET = join3(HOME_DIR, "wallets", "default.json");
+var HELIUS_URL = "https://www.helius.dev/";
+async function setup() {
+  mkdirSync2(HOME_DIR, { recursive: true });
+  loadEnv({ path: ENV_PATH });
+  const signer = await loadOrCreateWallet();
+  const rpcUrl = await loadOrPromptRpc();
+  iqlabs.setRpcUrl(rpcUrl);
+  const connection = new Connection(rpcUrl, "confirmed");
+  await healthCheck(connection);
+  await maybeWarnBalance(connection, signer);
+  return { client: new GitClient({ connection, signer }), signer, connection };
+}
+async function setupReadOnly() {
+  mkdirSync2(HOME_DIR, { recursive: true });
+  loadEnv({ path: ENV_PATH });
+  const rpcUrl = await loadOrPromptRpc();
+  iqlabs.setRpcUrl(rpcUrl);
+  return new Connection(rpcUrl, "confirmed");
+}
+async function loadOrCreateWallet() {
+  const cfg = readGlobalConfig();
+  let path = cfg.walletPath;
+  if (!path || !existsSync3(path)) {
+    const choice = await select({
+      message: "No Solana keypair configured. What would you like to do?",
+      choices: [
+        { name: "Generate a new keypair", value: "new" },
+        { name: "Use an existing keypair file", value: "existing" }
+      ]
+    });
+    if (choice === "new") {
+      mkdirSync2(dirname2(DEFAULT_WALLET), { recursive: true });
+      const kp = Keypair.generate();
+      writeFileSync2(DEFAULT_WALLET, JSON.stringify(Array.from(kp.secretKey)));
+      log.success(`Created ${DEFAULT_WALLET}`);
+      log.info(`pubkey: ${kp.publicKey.toBase58()}`);
+      writeGlobalConfig({ ...cfg, walletPath: DEFAULT_WALLET });
+      return kp;
+    }
+    path = await input({ message: "Path to keypair JSON file:" });
+    writeGlobalConfig({ ...cfg, walletPath: path });
+  }
+  return loadKeypairFromFile(path);
+}
+function loadKeypairFromFile(path) {
+  try {
+    const secret = JSON.parse(readFileSync2(path, "utf8"));
+    return Keypair.fromSecretKey(Uint8Array.from(secret));
+  } catch (e) {
+    fail(`Invalid keypair at ${path}: ${e.message}`);
+  }
+}
+async function loadOrPromptRpc() {
+  const cfg = readGlobalConfig();
+  const url = process.env.SOLANA_RPC_ENDPOINT ?? cfg.rpcUrl;
+  if (url) return url;
+  log.warn("No Solana RPC endpoint configured.");
+  log.info(`Get a free RPC URL from Helius: ${HELIUS_URL}`);
+  const entered = await input({ message: "Paste your RPC URL:" });
+  appendEnv("SOLANA_RPC_ENDPOINT", entered);
+  writeGlobalConfig({ ...cfg, rpcUrl: entered });
+  return entered;
+}
+async function healthCheck(connection) {
+  try {
+    await connection.getLatestBlockhash();
+  } catch (e) {
+    fail(`RPC health check failed: ${e.message}`);
+  }
+}
+async function maybeWarnBalance(connection, signer) {
+  const lamports = await connection.getBalance(signer.publicKey);
+  if (lamports >= 0.01 * LAMPORTS_PER_SOL) return;
+  log.warn(
+    `Low balance: ${lamports / LAMPORTS_PER_SOL} SOL on ${signer.publicKey.toBase58()}`
+  );
+  log.dim("On-chain writes need SOL \u2014 fund the address before pushing.");
+}
+function readGlobalConfig() {
+  try {
+    return JSON.parse(readFileSync2(CONFIG_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeGlobalConfig(cfg) {
+  mkdirSync2(HOME_DIR, { recursive: true });
+  writeFileSync2(CONFIG_PATH, JSON.stringify(cfg, null, 2));
+}
+function appendEnv(key, value) {
+  const line = `${key}=${value}
+`;
+  let existing = "";
+  try {
+    existing = readFileSync2(ENV_PATH, "utf8");
+  } catch {
+  }
+  const stripped = existing.split("\n").filter((l) => !l.startsWith(`${key}=`)).join("\n");
+  writeFileSync2(ENV_PATH, stripped.endsWith("\n") || !stripped ? stripped + line : `${stripped}
+${line}`);
+  process.env[key] = value;
+}
+
+// src/commands/create.ts
+function register2(program2) {
+  program2.command("create <name>").option("--public", "default visibility").option("--private").option("--description <text>", "", "").action(async (name, opts) => {
+    const cwd = process.cwd();
+    if (!existsSync4(join4(cwd, ".iqgit"))) initRepo(cwd);
+    const { client, signer } = await setup();
+    const isPublic = !opts.private;
+    const sp = spinner(`Creating on-chain repo ${name}...`).start();
+    try {
+      await client.createRepo({
+        name,
+        description: opts.description,
+        isPublic,
+        timestamp: Date.now()
+      });
+      sp.succeed(`Created ${signer.publicKey.toBase58()}/${name}`);
+    } catch (e) {
+      sp.fail(e.message);
+      process.exit(1);
+    }
+    writeConfig(cwd, {
+      owner: signer.publicKey.toBase58(),
+      repo: name,
+      isPublic
+    });
+    log.dim(`Next: edit files, then iqgit commit -m "..." && iqgit push`);
+  });
+}
+
+// src/commands/add.ts
+import { existsSync as existsSync5, statSync } from "fs";
+import { isAbsolute, relative as relative2, resolve, sep as sep2 } from "path";
+
+// src/core/scan.ts
+import { createHash } from "crypto";
+import { readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join5, relative, sep } from "path";
+import ignore from "ignore";
+function readScanFile(repoRoot, repoRel) {
+  const buf = readFileSync3(join5(repoRoot, repoRel));
+  const base64 = buf.toString("base64");
+  return {
+    path: repoRel,
+    base64,
+    hash: createHash("sha256").update(base64).digest("hex"),
+    size: buf.byteLength
+  };
+}
+function loadIgnore(repoRoot) {
+  const ig = ignore().add([".git/", ".iqgit/"]);
+  for (const name of [".gitignore", ".iqgitignore"]) {
+    try {
+      ig.add(readFileSync3(join5(repoRoot, name), "utf8"));
+    } catch {
+    }
+  }
+  return ig;
+}
+function scan(repoRoot) {
+  const out = [];
+  walk(repoRoot, repoRoot, loadIgnore(repoRoot), out);
+  return out;
+}
+function toScanMap(files) {
+  return Object.fromEntries(files.map((f) => [f.path, f.base64]));
+}
+function walk(root, dir, ig, out) {
+  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+    const abs = join5(dir, entry.name);
+    const rel = relative(root, abs).split(sep).join("/");
+    const relForIgnore = entry.isDirectory() ? `${rel}/` : rel;
+    if (ig.ignores(relForIgnore)) continue;
+    if (entry.isDirectory()) {
+      walk(root, abs, ig, out);
+      continue;
+    }
+    if (entry.isFile()) {
+      out.push(readScanFile(root, rel));
+    }
+  }
+}
+
+// src/commands/add.ts
+function register3(program2) {
+  program2.command("add <pathspec...>").description("stage paths for the next commit").action((pathspecs) => {
+    const cwd = findRepoRoot();
+    const allPaths = scan(cwd).map((f) => f.path);
+    const ig = loadIgnore(cwd);
+    const collected = new Set(readIndex(cwd));
+    for (const spec of pathspecs) {
+      const abs = isAbsolute(spec) ? spec : resolve(process.cwd(), spec);
+      if (!existsSync5(abs)) fail(`path does not exist: ${spec}`);
+      if (statSync(abs).isDirectory()) {
+        const prefix = relative2(cwd, abs).split(sep2).join("/");
+        const matches = prefix === "" ? allPaths : allPaths.filter((p) => p === prefix || p.startsWith(`${prefix}/`));
+        for (const p of matches) collected.add(p);
+      } else {
+        const rel = relative2(cwd, abs).split(sep2).join("/");
+        if (ig.ignores(rel)) {
+          log.dim(`ignored: ${rel}`);
+          continue;
+        }
+        collected.add(rel);
+      }
+    }
+    writeIndex(cwd, [...collected]);
+    log.success(`staged ${collected.size} path(s)`);
+  });
+}
+
+// src/commands/reset.ts
+import { isAbsolute as isAbsolute2, relative as relative3, resolve as resolve2, sep as sep3 } from "path";
+function register4(program2) {
+  program2.command("reset [pathspec...]").description("unstage paths (no args clears the index)").action((pathspecs) => {
+    const cwd = findRepoRoot();
+    if (pathspecs.length === 0) {
+      writeIndex(cwd, []);
+      log.success("index cleared");
+      return;
+    }
+    const removeRels = pathspecs.map((spec) => {
+      const abs = isAbsolute2(spec) ? spec : resolve2(process.cwd(), spec);
+      return relative3(cwd, abs).split(sep3).join("/");
+    });
+    const next = readIndex(cwd).filter(
+      (p) => !removeRels.some((r) => p === r || p.startsWith(`${r}/`))
+    );
+    writeIndex(cwd, next);
+    log.success(`index now has ${next.length} path(s)`);
+  });
+}
+
+// src/commands/commit.ts
+import { randomUUID } from "crypto";
+import { existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+
+// src/core/tree.ts
+import {
+  IQGIT_ROOT_ID,
+  commitTableHint
+} from "@iqlabs-official/git-sdk/node";
+import { getDbRootPda, getTablePda } from "@iqlabs-official/solana-sdk/contract";
+import { toSeedBytes } from "@iqlabs-official/solana-sdk/utils";
+
+// src/core/gateway.ts
+import iqlabs2 from "@iqlabs-official/solana-sdk";
+import { loadBlob, loadTree } from "@iqlabs-official/git-sdk/node";
+var DEFAULT_GATEWAYS = [
+  "https://gateway.solanainternet.com",
+  "https://gateway.iqlabs.dev",
+  "https://fem4pe7sthdm5f9fkhc1fnmpos.ingress.akashprovid.com",
+  "https://fem4pe7sthdm5f9fkhc1fnmpos.ingress.cpu.aesservices.net"
+];
+function getGatewayUrls() {
+  const raw = process.env.GATEWAY_URL?.trim();
+  if (raw === void 0 || raw === "") return DEFAULT_GATEWAYS;
+  if (raw.toLowerCase() === "off") return [];
+  return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+async function gwFetch(path, timeoutMs = 8e3) {
+  for (const base of getGatewayUrls()) {
+    try {
+      const res = await fetch(`${base}${path}`, { signal: AbortSignal.timeout(timeoutMs) });
+      if (res.ok) return res;
+    } catch {
+    }
+  }
+  return null;
+}
+async function gwFetchRows(tablePda, limit = 50, before) {
+  const path = `/table/${tablePda}/rows?limit=${limit}` + (before ? `&before=${before}` : "");
+  const res = await gwFetch(path);
+  if (res !== null) {
+    try {
+      const data = await res.json();
+      return data.rows ?? [];
+    } catch {
+    }
+  }
+  return iqlabs2.reader.readTableRows(tablePda, { limit, before });
+}
+async function gwFetchAllRows(tablePda, maxRows = 200) {
+  const all = [];
+  let before;
+  while (all.length < maxRows) {
+    const limit = Math.min(50, maxRows - all.length);
+    const rows = await gwFetchRows(tablePda, limit, before);
+    all.push(...rows);
+    if (rows.length < limit) break;
+    const last = rows[rows.length - 1];
+    if (!last.__txSignature) break;
+    before = last.__txSignature;
+  }
+  return all;
+}
+async function gwLoadTreeJson(txSignature) {
+  const res = await gwFetch(`/data/${txSignature}`);
+  if (res !== null) {
+    try {
+      const env = await res.json();
+      if (typeof env.data === "string") return JSON.parse(env.data);
+    } catch {
+    }
+  }
+  return await loadTree(txSignature);
+}
+async function gwLoadBlobBase64(txSignature) {
+  const res = await gwFetch(`/data/${txSignature}`);
+  if (res !== null) {
+    try {
+      const env = await res.json();
+      if (typeof env.data === "string") return env.data;
+    } catch {
+    }
+  }
+  return await loadBlob(txSignature);
+}
+async function gwNotify(tablePda, txSignature, row, signer) {
+  const body = JSON.stringify({ txSignature, row, signer });
+  for (const base of getGatewayUrls()) {
+    try {
+      const res = await fetch(`${base}/table/${tablePda}/notify`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body,
+        signal: AbortSignal.timeout(3e3)
+      });
+      if (res.ok) return;
+    } catch {
+    }
+  }
+}
+
+// src/core/tree.ts
+async function resolveBaseTree(cwd, owner, repoName) {
+  const last = listPending(cwd).at(-1);
+  if (last) return readPendingTree(last);
+  const head = readHead(cwd);
+  if (head === null) return {};
+  const dbRoot = getDbRootPda(toSeedBytes(IQGIT_ROOT_ID));
+  const commitTable = getTablePda(dbRoot, toSeedBytes(commitTableHint(owner, repoName)));
+  const history = await gwFetchAllRows(commitTable.toBase58(), 200);
+  const headCommit = history.find((c) => c.id === head);
+  if (!headCommit) {
+    throw new Error(`HEAD ${head.slice(0, 7)} not found in on-chain history`);
+  }
+  const onChain = await gwLoadTreeJson(headCommit.treeTxId);
+  const out = {};
+  for (const [p, entry] of Object.entries(onChain)) {
+    out[p] = { hash: entry.hash, size: 0 };
+  }
+  return out;
+}
+
+// src/commands/commit.ts
+var LARGE_FILE_THRESHOLD = 1024 * 1024;
+function register5(program2) {
+  program2.command("commit").requiredOption("-m, --message <msg>", "commit message").option("--no-warn-large", "skip 1MB confirmation prompt").action(async (opts) => {
+    const cwd = findRepoRoot();
+    const cfg = readConfig(cwd);
+    if (!cfg.owner) fail("repo not yet created on-chain \u2014 run iqgit create first");
+    const indexPaths = readIndex(cwd);
+    if (indexPaths.length === 0) {
+      fail("nothing staged \u2014 use `iqgit add <path>` first");
+    }
+    const stagedFiles = [];
+    const stagedDeletes = [];
+    for (const p of indexPaths) {
+      if (existsSync6(join6(cwd, p))) {
+        stagedFiles.push(readScanFile(cwd, p));
+      } else {
+        stagedDeletes.push(p);
+      }
+    }
+    const big = stagedFiles.filter((f) => f.size > LARGE_FILE_THRESHOLD);
+    if (big.length > 0 && opts.warnLarge) {
+      log.warn("Large files (>1MB) \u2014 on-chain upload will be costly:");
+      for (const b of big) log.info(`  ${b.path}  ${formatSize(b.size)}`);
+      const ok = await confirm({ message: "Include them?" });
+      if (!ok) {
+        log.dim("Tip: add to .iqgitignore to skip on-chain upload only.");
+        return;
+      }
+    }
+    await setupReadOnly();
+    const sp = spinner("fetching base tree from chain...").start();
+    let baseTree;
+    try {
+      baseTree = await resolveBaseTree(cwd, cfg.owner, cfg.repo);
+      sp.succeed("fetched base tree");
+    } catch (e) {
+      sp.fail(e.message);
+      throw e;
+    }
+    const tree = { ...baseTree };
+    const blobs = /* @__PURE__ */ new Map();
+    for (const f of stagedFiles) {
+      tree[f.path] = { hash: f.hash, size: f.size };
+      blobs.set(f.hash, f.base64);
+    }
+    for (const p of stagedDeletes) {
+      delete tree[p];
+    }
+    const last = listPending(cwd).at(-1);
+    const meta = {
+      id: randomUUID(),
+      message: opts.message,
+      parentCommitId: last?.meta.id ?? readHead(cwd),
+      timestamp: Date.now(),
+      author: cfg.owner,
+      treeTxId: null,
+      committedSig: null
+    };
+    appendPending(cwd, meta, tree, blobs);
+    writeIndex(cwd, []);
+    const totalSize = stagedFiles.reduce((sum, f) => sum + f.size, 0);
+    log.success(`commit ${meta.id.slice(0, 7)} saved locally`);
+    log.info(
+      `  ${stagedFiles.length} file(s) added/modified, ${stagedDeletes.length} removed, ${formatSize(totalSize)}`
+    );
+    log.dim("Run: iqgit push  to upload on-chain");
+  });
+}
+
+// src/commands/push.ts
+import {
+  IQGIT_ROOT_ID as IQGIT_ROOT_ID2,
+  commitTableHint as commitTableHint2,
+  uploadBlob,
+  uploadTree,
+  writeCommit
+} from "@iqlabs-official/git-sdk/node";
+import { getDbRootPda as getDbRootPda2, getTablePda as getTablePda2 } from "@iqlabs-official/solana-sdk/contract";
+import { toSeedBytes as toSeedBytes2 } from "@iqlabs-official/solana-sdk/utils";
+function register6(program2) {
+  program2.command("push").action(async () => {
+    const cwd = findRepoRoot();
+    const cfg = readConfig(cwd);
+    const queue = listPending(cwd);
+    if (queue.length === 0) {
+      log.info("nothing to push");
+      return;
+    }
+    const { signer, connection } = await setup();
+    for (const p of queue) {
+      log.info(`pushing ${p.meta.id.slice(0, 7)} "${p.meta.message}"`);
+      try {
+        await pushOne(connection, signer, cwd, cfg.repo, p);
+      } catch (e) {
+        fail(
+          `failed at ${p.meta.id.slice(0, 7)}: ${e.message}
+re-run "iqgit push" to resume.`
+        );
+      }
+      writeHead(cwd, p.meta.id);
+      discardPending(p);
+      log.success(`  pushed ${p.meta.id.slice(0, 7)}`);
+    }
+  });
+}
+async function pushOne(connection, signer, cwd, repoName, p) {
+  const tree = readPendingTree(p);
+  const newTree = {};
+  const total = Object.keys(tree).length;
+  const sp = spinner(`  blobs 0/${total}`).start();
+  let done = 0;
+  let reused = 0;
+  for (const [path, { hash }] of Object.entries(tree)) {
+    const cached = cacheGet(cwd, hash);
+    if (cached) {
+      newTree[path] = { txId: cached.txId, hash };
+      reused++;
+    } else {
+      const base64 = readPendingBlob(p, hash);
+      const { txId } = await uploadBlob(connection, signer, path, base64, {});
+      cacheSet(cwd, hash, { txId, uploadedAt: Date.now() });
+      newTree[path] = { txId, hash };
+    }
+    done++;
+    sp.text = `  blobs ${done}/${total} (${reused} reused)`;
+  }
+  sp.succeed(`  blobs ${done}/${total} (${reused} reused)`);
+  let treeTxId = p.meta.treeTxId;
+  if (!treeTxId) {
+    treeTxId = await uploadTree(connection, signer, newTree);
+    updatePendingMeta(p, { treeTxId });
+  }
+  if (!p.meta.committedSig) {
+    const commit = {
+      id: p.meta.id,
+      message: p.meta.message,
+      treeTxId,
+      parentCommitId: p.meta.parentCommitId ?? void 0,
+      timestamp: p.meta.timestamp,
+      author: p.meta.author
+    };
+    const sig = await writeCommit(connection, signer, repoName, commit);
+    updatePendingMeta(p, { committedSig: sig });
+    const dbRoot = getDbRootPda2(toSeedBytes2(IQGIT_ROOT_ID2));
+    const tablePda = getTablePda2(dbRoot, toSeedBytes2(commitTableHint2(commit.author, repoName)));
+    void gwNotify(tablePda.toBase58(), sig, void 0, signer.publicKey.toBase58());
+  }
+}
+
+// src/commands/clone.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, join as join7 } from "path";
+import { Buffer as Buffer2 } from "buffer";
+import {
+  IQGIT_ROOT_ID as IQGIT_ROOT_ID3,
+  commitTableHint as commitTableHint3,
+  repoListHint
+} from "@iqlabs-official/git-sdk/node";
+import { getDbRootPda as getDbRootPda3, getTablePda as getTablePda3 } from "@iqlabs-official/solana-sdk/contract";
+import { toSeedBytes as toSeedBytes3 } from "@iqlabs-official/solana-sdk/utils";
+function register7(program2) {
+  program2.command("clone <slug> [dir]").action(async (slug, dir) => {
+    const [owner, repoName] = slug.split("/");
+    if (!owner || !repoName) fail("expected <owner>/<repo>");
+    const target = dir ?? repoName;
+    if (existsSync7(target)) fail(`${target} already exists`);
+    mkdirSync3(target, { recursive: true });
+    await setupReadOnly();
+    const dbRoot = getDbRootPda3(toSeedBytes3(IQGIT_ROOT_ID3));
+    const sp = spinner(`cloning ${slug}...`).start();
+    const commitTable = getTablePda3(dbRoot, toSeedBytes3(commitTableHint3(owner, repoName)));
+    const commits = await gwFetchAllRows(commitTable.toBase58(), 200);
+    if (commits.length === 0) {
+      sp.fail(`no commits in ${slug}`);
+      process.exit(1);
+    }
+    const latest = [...commits].sort(
+      (a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0)
+    )[0];
+    const tree = await gwLoadTreeJson(latest.treeTxId);
+    const paths = Object.entries(tree);
+    let i = 0;
+    for (const [path, entry] of paths) {
+      i++;
+      sp.text = `cloning ${slug}... (${i}/${paths.length}) ${path}`;
+      const base64 = await gwLoadBlobBase64(entry.txId);
+      const abs = join7(target, path);
+      mkdirSync3(dirname3(abs), { recursive: true });
+      writeFileSync3(abs, Buffer2.from(base64, "base64"));
+    }
+    sp.succeed(`cloned ${paths.length} file(s) to ${target}/`);
+    const ownerListPda = getTablePda3(dbRoot, toSeedBytes3(repoListHint(owner)));
+    const repos = await gwFetchAllRows(ownerListPda.toBase58(), 200);
+    const meta = repos.find((r) => r.name === repoName);
+    const isPublic = meta?.isPublic ?? true;
+    initRepo(target);
+    writeConfig(target, { owner, repo: repoName, isPublic });
+    writeHead(target, latest.id);
+  });
+}
+
+// src/commands/restore.ts
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname4, join as join8 } from "path";
+function register8(program2) {
+  program2.command("restore [commitId]").option("--force", "discard uncommitted changes").action(async (commitId, opts) => {
+    const cwd = findRepoRoot();
+    const cfg = readConfig(cwd);
+    const { client } = await setup();
+    if (!opts.force) {
+      const { added, modified } = await client.status(
+        cfg.owner,
+        cfg.repo,
+        toScanMap(scan(cwd))
+      );
+      if (added.length || modified.length) {
+        fail("uncommitted changes \u2014 commit them or pass --force");
+      }
+    }
+    const target = commitId ?? "latest";
+    const sp = spinner(`restoring ${target}...`).start();
+    const c = await client.checkout(cfg.repo, target, async (path, base64) => {
+      const abs = join8(cwd, path);
+      mkdirSync4(dirname4(abs), { recursive: true });
+      writeFileSync4(abs, Buffer.from(base64, "base64"));
+    });
+    sp.succeed(`restored ${c.id.slice(0, 7)} "${c.message}"`);
+    if (target === "latest") writeHead(cwd, c.id);
+  });
+}
+
+// src/commands/log.ts
+import {
+  IQGIT_ROOT_ID as IQGIT_ROOT_ID4,
+  commitTableHint as commitTableHint4
+} from "@iqlabs-official/git-sdk/node";
+import { getDbRootPda as getDbRootPda4, getTablePda as getTablePda4 } from "@iqlabs-official/solana-sdk/contract";
+import { toSeedBytes as toSeedBytes4 } from "@iqlabs-official/solana-sdk/utils";
+function register9(program2) {
+  program2.command("log").option("--limit <n>", "max entries", "20").option("--owner <pubkey>").option("--repo <name>").action(async (opts) => {
+    let owner = opts.owner;
+    let repoName = opts.repo;
+    if (!owner || !repoName) {
+      const cfg = readConfig(findRepoRoot());
+      owner ??= cfg.owner;
+      repoName ??= cfg.repo;
+    }
+    await setupReadOnly();
+    const dbRoot = getDbRootPda4(toSeedBytes4(IQGIT_ROOT_ID4));
+    const tablePda = getTablePda4(dbRoot, toSeedBytes4(commitTableHint4(owner, repoName)));
+    const commits = await gwFetchAllRows(tablePda.toBase58(), Number(opts.limit));
+    const sorted = [...commits].sort((a, b) => b.timestamp - a.timestamp);
+    for (const c of sorted) {
+      log.info(formatCommit(c));
+      log.dim(`        author: ${c.author}`);
+      log.dim(`        tree:   ${c.treeTxId}`);
+      log.info("");
+    }
+  });
+}
+
+// src/commands/status.ts
+function register10(program2) {
+  program2.command("status").action(async () => {
+    const cwd = findRepoRoot();
+    const cfg = readConfig(cwd);
+    const head = readHead(cwd);
+    const pending = listPending(cwd);
+    const index = new Set(readIndex(cwd));
+    const files = scan(cwd);
+    const filesByPath = new Map(files.map((f) => [f.path, f]));
+    if (pending.length === 0 && head !== null) await setupReadOnly();
+    const base = await resolveBaseTree(cwd, cfg.owner, cfg.repo);
+    const stagedAddedOrModified = [];
+    const stagedDeleted = [];
+    const unstagedAdded = [];
+    const unstagedModified = [];
+    const unstagedDeleted = [];
+    const allPaths = /* @__PURE__ */ new Set([...Object.keys(base), ...files.map((f) => f.path)]);
+    for (const p of allPaths) {
+      const inBase = base[p];
+      const inWorking = filesByPath.get(p);
+      const isStaged = index.has(p);
+      if (inWorking && !inBase) {
+        (isStaged ? stagedAddedOrModified : unstagedAdded).push(p);
+      } else if (!inWorking && inBase) {
+        (isStaged ? stagedDeleted : unstagedDeleted).push(p);
+      } else if (inWorking && inBase && inWorking.hash !== inBase.hash) {
+        (isStaged ? stagedAddedOrModified : unstagedModified).push(p);
+      }
+    }
+    log.info(`On HEAD: ${head ? head.slice(0, 7) : "(no commits yet)"}`);
+    if (pending.length) {
+      log.info("");
+      log.info(`Pending commits (not yet pushed): ${pending.length}`);
+      for (const p of pending) {
+        log.info(`  ${p.meta.id.slice(0, 7)}  "${p.meta.message}"`);
+      }
+    }
+    if (stagedAddedOrModified.length || stagedDeleted.length) {
+      log.info("");
+      log.info("Staged for next commit:");
+      for (const f of stagedAddedOrModified) log.info(`  ${f}`);
+      for (const f of stagedDeleted) log.info(`  deleted:  ${f}`);
+    }
+    if (unstagedAdded.length || unstagedModified.length || unstagedDeleted.length) {
+      log.info("");
+      log.info("Unstaged changes:");
+      for (const f of unstagedAdded) log.info(`  added:    ${f}`);
+      for (const f of unstagedModified) log.info(`  modified: ${f}`);
+      for (const f of unstagedDeleted) log.info(`  deleted:  ${f}`);
+    }
+    const clean = pending.length === 0 && stagedAddedOrModified.length === 0 && stagedDeleted.length === 0 && unstagedAdded.length === 0 && unstagedModified.length === 0 && unstagedDeleted.length === 0;
+    if (clean) log.info("clean");
+  });
+}
+
+// src/commands/registry.ts
+import {
+  IQGIT_ROOT_ID as IQGIT_ROOT_ID5,
+  REGISTRY_HINT
+} from "@iqlabs-official/git-sdk/node";
+import { getDbRootPda as getDbRootPda5, getTablePda as getTablePda5 } from "@iqlabs-official/solana-sdk/contract";
+import { toSeedBytes as toSeedBytes5 } from "@iqlabs-official/solana-sdk/utils";
+function register11(program2) {
+  program2.command("registry").description("browse the public on-chain repo gallery").option("--limit <n>", "max entries", "20").action(async (opts) => {
+    await setupReadOnly();
+    const dbRoot = getDbRootPda5(toSeedBytes5(IQGIT_ROOT_ID5));
+    const tablePda = getTablePda5(dbRoot, toSeedBytes5(REGISTRY_HINT));
+    const entries = await gwFetchAllRows(tablePda.toBase58(), Number(opts.limit));
+    if (entries.length === 0) {
+      log.dim("registry empty");
+      return;
+    }
+    for (const e of entries) {
+      log.info(`${e.owner.slice(0, 8)}\u2026/${e.repo}  ${e.description ?? ""}`);
+    }
+  });
+}
+
+// src/commands/config.ts
+var KNOWN_KEYS = ["walletPath", "rpcUrl"];
+function register12(program2) {
+  program2.command("config [key] [value]").option("--unset <key>").action((key, value, opts) => {
+    const cfg = readGlobalConfig();
+    if (opts.unset) {
+      ensureKnown(opts.unset);
+      delete cfg[opts.unset];
+      writeGlobalConfig(cfg);
+      log.success(`unset ${opts.unset}`);
+      return;
+    }
+    if (!key) {
+      for (const [k, v] of Object.entries(cfg)) {
+        if (v !== void 0) log.info(`${k}=${v}`);
+      }
+      return;
+    }
+    ensureKnown(key);
+    if (value === void 0) {
+      log.info(cfg[key] ?? "");
+      return;
+    }
+    cfg[key] = value;
+    writeGlobalConfig(cfg);
+    log.success(`set ${key}=${value}`);
+  });
+}
+function ensureKnown(key) {
+  if (!KNOWN_KEYS.includes(key)) {
+    fail(`unknown config key: ${key}
+known: ${KNOWN_KEYS.join(", ")}`);
+  }
+}
+
+// src/commands/wallet.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname5 } from "path";
+import { Keypair as Keypair2, LAMPORTS_PER_SOL as LAMPORTS_PER_SOL2 } from "@solana/web3.js";
+import { IQGIT_ROOT_ID as IQGIT_ROOT_ID6, repoListHint as repoListHint2 } from "@iqlabs-official/git-sdk/node";
+import { getDbRootPda as getDbRootPda6, getTablePda as getTablePda6 } from "@iqlabs-official/solana-sdk/contract";
+import { toSeedBytes as toSeedBytes6 } from "@iqlabs-official/solana-sdk/utils";
+function register13(program2) {
+  program2.command("wallet <action>").description("new | show | balance | repos").action(async (action) => {
+    switch (action) {
+      case "new":
+        return walletNew();
+      case "show":
+        return walletShow();
+      case "balance":
+        return walletBalance();
+      case "repos":
+        return walletRepos();
+      default:
+        fail(`unknown action: ${action}`);
+    }
+  });
+}
+function walletNew() {
+  if (existsSync8(DEFAULT_WALLET)) {
+    fail(`default wallet exists at ${DEFAULT_WALLET}; remove it first`);
+  }
+  mkdirSync5(dirname5(DEFAULT_WALLET), { recursive: true });
+  const kp = Keypair2.generate();
+  writeFileSync5(DEFAULT_WALLET, JSON.stringify(Array.from(kp.secretKey)));
+  log.success(`created ${DEFAULT_WALLET}`);
+  log.info(`pubkey: ${kp.publicKey.toBase58()}`);
+}
+function walletShow() {
+  const path = readGlobalConfig().walletPath ?? DEFAULT_WALLET;
+  const kp = loadKeypairFromFile(path);
+  log.info(`path:   ${path}`);
+  log.info(`pubkey: ${kp.publicKey.toBase58()}`);
+}
+async function walletBalance() {
+  const { signer, connection } = await setup();
+  const lamports = await connection.getBalance(signer.publicKey);
+  log.info(signer.publicKey.toBase58());
+  log.info(`${lamports / LAMPORTS_PER_SOL2} SOL`);
+}
+async function walletRepos() {
+  const { signer } = await setup();
+  const owner = signer.publicKey.toBase58();
+  const dbRoot = getDbRootPda6(toSeedBytes6(IQGIT_ROOT_ID6));
+  const tablePda = getTablePda6(dbRoot, toSeedBytes6(repoListHint2(owner)));
+  const repos = await gwFetchAllRows(tablePda.toBase58(), 200);
+  if (repos.length === 0) {
+    log.dim("no repos yet");
+    return;
+  }
+  for (const r of repos) {
+    const visibility = r.isPublic ? "public " : "private";
+    log.info(`${visibility}  ${r.name}  ${r.description}`);
+  }
+}
+
+// src/cli.ts
+var program = new Command("iqgit").description("On-chain Git for Solana").version("0.1.0");
+register(program);
+register2(program);
+register3(program);
+register4(program);
+register5(program);
+register6(program);
+register7(program);
+register8(program);
+register9(program);
+register10(program);
+register11(program);
+register12(program);
+register13(program);
+program.parseAsync(process.argv);
+//# sourceMappingURL=cli.js.map