@newtype-ai/nit 0.1.0

package/dist/chunk-5EGCFUZ7.js

@@ -0,0 +1,927 @@
+// nit — version control for agent cards
+
+// src/index.ts
+import { promises as fs6, statSync } from "fs";
+import { join as join6, basename as basename2, resolve } from "path";
+
+// src/objects.ts
+import { createHash } from "crypto";
+import { promises as fs } from "fs";
+import { join } from "path";
+function hashObject(type, content) {
+  const buf = Buffer.from(content, "utf-8");
+  const header = `${type} ${buf.byteLength}\0`;
+  const hash = createHash("sha256");
+  hash.update(header);
+  hash.update(buf);
+  return hash.digest("hex");
+}
+async function writeObject(nitDir, type, content) {
+  const hex = hashObject(type, content);
+  const dir = join(nitDir, "objects", hex.slice(0, 2));
+  const file = join(dir, hex.slice(2));
+  try {
+    await fs.access(file);
+    return hex;
+  } catch {
+  }
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(file, content, "utf-8");
+  return hex;
+}
+async function readObject(nitDir, hash) {
+  const file = join(nitDir, "objects", hash.slice(0, 2), hash.slice(2));
+  try {
+    return await fs.readFile(file, "utf-8");
+  } catch {
+    throw new Error(`Object not found: ${hash}`);
+  }
+}
+function serializeCommit(commit2) {
+  const lines = [];
+  lines.push(`card ${commit2.card}`);
+  if (commit2.parent !== null) {
+    lines.push(`parent ${commit2.parent}`);
+  }
+  lines.push(`author ${commit2.author} ${commit2.timestamp}`);
+  lines.push("");
+  lines.push(commit2.message);
+  return lines.join("\n");
+}
+function parseCommit(hash, raw) {
+  const lines = raw.split("\n");
+  let card = "";
+  let parent = null;
+  let author = "";
+  let timestamp = 0;
+  let messageStart = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === "") {
+      messageStart = i + 1;
+      break;
+    }
+    if (line.startsWith("card ")) {
+      card = line.slice(5);
+    } else if (line.startsWith("parent ")) {
+      parent = line.slice(7);
+    } else if (line.startsWith("author ")) {
+      const authorPart = line.slice(7);
+      const lastSpace = authorPart.lastIndexOf(" ");
+      author = authorPart.slice(0, lastSpace);
+      timestamp = parseInt(authorPart.slice(lastSpace + 1), 10);
+    }
+  }
+  if (!card) {
+    throw new Error(`Malformed commit object ${hash}: missing card hash`);
+  }
+  const message = messageStart >= 0 ? lines.slice(messageStart).join("\n") : "";
+  return {
+    type: "commit",
+    hash,
+    card,
+    parent,
+    author,
+    timestamp,
+    message
+  };
+}
+
+// src/refs.ts
+import { promises as fs2 } from "fs";
+import { join as join2 } from "path";
+async function getHead(nitDir) {
+  const headPath = join2(nitDir, "HEAD");
+  const content = (await fs2.readFile(headPath, "utf-8")).trim();
+  if (!content.startsWith("ref: ")) {
+    throw new Error(
+      `HEAD is in an unexpected state: "${content}". Only symbolic refs are supported.`
+    );
+  }
+  return { type: "ref", ref: content.slice(5) };
+}
+async function resolveHead(nitDir) {
+  const head = await getHead(nitDir);
+  const refPath = join2(nitDir, head.ref);
+  try {
+    return (await fs2.readFile(refPath, "utf-8")).trim();
+  } catch {
+    throw new Error(
+      `Branch ref ${head.ref} does not exist. Repository may be empty.`
+    );
+  }
+}
+async function getCurrentBranch(nitDir) {
+  const head = await getHead(nitDir);
+  const prefix = "refs/heads/";
+  if (!head.ref.startsWith(prefix)) {
+    throw new Error(`HEAD ref has unexpected format: ${head.ref}`);
+  }
+  return head.ref.slice(prefix.length);
+}
+async function setBranch(nitDir, branch2, commitHash) {
+  const refPath = join2(nitDir, "refs", "heads", branch2);
+  await fs2.mkdir(join2(nitDir, "refs", "heads"), { recursive: true });
+  await fs2.writeFile(refPath, commitHash + "\n", "utf-8");
+}
+async function getBranch(nitDir, branch2) {
+  const refPath = join2(nitDir, "refs", "heads", branch2);
+  try {
+    return (await fs2.readFile(refPath, "utf-8")).trim();
+  } catch {
+    return null;
+  }
+}
+async function listBranches(nitDir) {
+  const headsDir = join2(nitDir, "refs", "heads");
+  const branches = [];
+  try {
+    const entries = await fs2.readdir(headsDir);
+    for (const name of entries) {
+      const refPath = join2(headsDir, name);
+      const stat = await fs2.stat(refPath);
+      if (stat.isFile()) {
+        const commitHash = (await fs2.readFile(refPath, "utf-8")).trim();
+        branches.push({ name, commitHash });
+      }
+    }
+  } catch {
+  }
+  return branches.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function setHead(nitDir, branch2) {
+  const headPath = join2(nitDir, "HEAD");
+  await fs2.writeFile(headPath, `ref: refs/heads/${branch2}
+`, "utf-8");
+}
+async function setRemoteRef(nitDir, remote2, branch2, commitHash) {
+  const dir = join2(nitDir, "refs", "remote", remote2);
+  await fs2.mkdir(dir, { recursive: true });
+  await fs2.writeFile(join2(dir, branch2), commitHash + "\n", "utf-8");
+}
+async function getRemoteRef(nitDir, remote2, branch2) {
+  const refPath = join2(nitDir, "refs", "remote", remote2, branch2);
+  try {
+    return (await fs2.readFile(refPath, "utf-8")).trim();
+  } catch {
+    return null;
+  }
+}
+
+// src/identity.ts
+import {
+  generateKeyPairSync,
+  createPrivateKey,
+  createPublicKey,
+  sign,
+  verify
+} from "crypto";
+import { promises as fs3 } from "fs";
+import { join as join3 } from "path";
+function base64urlToBase64(b64url) {
+  let s = b64url.replace(/-/g, "+").replace(/_/g, "/");
+  while (s.length % 4 !== 0) s += "=";
+  return s;
+}
+function base64ToBase64url(b64) {
+  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function generateKeypair(nitDir) {
+  const identityDir = join3(nitDir, "identity");
+  await fs3.mkdir(identityDir, { recursive: true });
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519");
+  const pubJwk = publicKey.export({ format: "jwk" });
+  const privJwk = privateKey.export({ format: "jwk" });
+  const pubBase64 = base64urlToBase64(pubJwk.x);
+  const privBase64 = base64urlToBase64(privJwk.d);
+  const pubPath = join3(identityDir, "agent.pub");
+  const keyPath = join3(identityDir, "agent.key");
+  await fs3.writeFile(pubPath, pubBase64 + "\n", "utf-8");
+  await fs3.writeFile(keyPath, privBase64 + "\n", {
+    mode: 384,
+    encoding: "utf-8"
+  });
+  return { publicKey: pubBase64, privateKey: privBase64 };
+}
+async function loadPublicKey(nitDir) {
+  const pubPath = join3(nitDir, "identity", "agent.pub");
+  try {
+    return (await fs3.readFile(pubPath, "utf-8")).trim();
+  } catch {
+    throw new Error(
+      "No identity found. Run `nit init` to generate a keypair."
+    );
+  }
+}
+async function loadPrivateKey(nitDir) {
+  const pubBase64 = await loadPublicKey(nitDir);
+  const keyPath = join3(nitDir, "identity", "agent.key");
+  let privBase64;
+  try {
+    privBase64 = (await fs3.readFile(keyPath, "utf-8")).trim();
+  } catch {
+    throw new Error(
+      "Private key not found at .nit/identity/agent.key. Regenerate with `nit init`."
+    );
+  }
+  const xB64url = base64ToBase64url(pubBase64);
+  const dB64url = base64ToBase64url(privBase64);
+  return createPrivateKey({
+    key: { kty: "OKP", crv: "Ed25519", x: xB64url, d: dB64url },
+    format: "jwk"
+  });
+}
+function formatPublicKeyField(pubBase64) {
+  return `ed25519:${pubBase64}`;
+}
+function parsePublicKeyField(field) {
+  const prefix = "ed25519:";
+  if (!field.startsWith(prefix)) {
+    throw new Error(
+      `Invalid publicKey format: expected "ed25519:<base64>", got "${field}"`
+    );
+  }
+  return field.slice(prefix.length);
+}
+async function signChallenge(nitDir, challenge) {
+  const privateKey = await loadPrivateKey(nitDir);
+  const sig = sign(null, Buffer.from(challenge, "utf-8"), privateKey);
+  return sig.toString("base64");
+}
+function verifySignature(pubBase64, challenge, signatureBase64) {
+  const xB64url = base64ToBase64url(pubBase64);
+  const publicKeyObj = createPublicKey({
+    key: { kty: "OKP", crv: "Ed25519", x: xB64url },
+    format: "jwk"
+  });
+  return verify(
+    null,
+    Buffer.from(challenge, "utf-8"),
+    publicKeyObj,
+    Buffer.from(signatureBase64, "base64")
+  );
+}
+
+// src/config.ts
+import { promises as fs4 } from "fs";
+import { join as join4 } from "path";
+var CONFIG_FILE = "config";
+async function readConfig(nitDir) {
+  const configPath = join4(nitDir, CONFIG_FILE);
+  let raw;
+  try {
+    raw = await fs4.readFile(configPath, "utf-8");
+  } catch {
+    return { remotes: {} };
+  }
+  return parseConfig(raw);
+}
+async function getRemoteCredential(nitDir, remoteName) {
+  const config = await readConfig(nitDir);
+  return config.remotes[remoteName]?.credential ?? null;
+}
+function parseConfig(raw) {
+  const remotes = {};
+  let currentRemote = null;
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    const sectionMatch = trimmed.match(/^\[remote\s+"([^"]+)"\]$/);
+    if (sectionMatch) {
+      currentRemote = sectionMatch[1];
+      if (!remotes[currentRemote]) {
+        remotes[currentRemote] = {};
+      }
+      continue;
+    }
+    if (currentRemote !== null) {
+      const kvMatch = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
+      if (kvMatch) {
+        const [, key, value] = kvMatch;
+        if (key === "credential") {
+          remotes[currentRemote].credential = value.trim();
+        }
+      }
+    }
+  }
+  return { remotes };
+}
+
+// src/skills.ts
+import { promises as fs5 } from "fs";
+import { join as join5 } from "path";
+import { homedir } from "os";
+async function discoverSkills(projectDir2) {
+  const home = homedir();
+  const searchDirs = [
+    // Project-local (all known agent frameworks)
+    join5(projectDir2, ".claude", "skills"),
+    join5(projectDir2, ".cursor", "skills"),
+    join5(projectDir2, ".windsurf", "skills"),
+    join5(projectDir2, ".codex", "skills"),
+    join5(projectDir2, ".agents", "skills"),
+    // User-global
+    join5(home, ".claude", "skills"),
+    // Claude Code + Cursor (shared)
+    join5(home, ".codex", "skills"),
+    // Codex CLI
+    join5(home, ".codeium", "windsurf", "skills")
+    // Windsurf
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const skills = [];
+  for (const searchDir of searchDirs) {
+    const found = await scanSkillDir(searchDir);
+    for (const skill of found) {
+      if (!seen.has(skill.id)) {
+        seen.add(skill.id);
+        skills.push(skill);
+      }
+    }
+  }
+  return skills;
+}
+async function resolveSkillPointers(card, projectDir2) {
+  const discovered = await discoverSkills(projectDir2);
+  const skillMap = new Map(discovered.map((s) => [s.id, s]));
+  const resolvedSkills = card.skills.map((skill) => {
+    const meta = skillMap.get(skill.id);
+    if (!meta) return skill;
+    return {
+      ...skill,
+      name: meta.name,
+      description: meta.description
+    };
+  });
+  return { ...card, skills: resolvedSkills };
+}
+async function scanSkillDir(dir) {
+  let entries;
+  try {
+    entries = await fs5.readdir(dir);
+  } catch {
+    return [];
+  }
+  const skills = [];
+  for (const entry of entries) {
+    const skillMdPath = join5(dir, entry, "SKILL.md");
+    try {
+      const content = await fs5.readFile(skillMdPath, "utf-8");
+      const meta = parseFrontmatter(content, entry, skillMdPath);
+      if (meta) skills.push(meta);
+    } catch {
+    }
+  }
+  return skills;
+}
+function parseFrontmatter(content, dirName, filePath) {
+  const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!fmMatch) return null;
+  const fmBlock = fmMatch[1];
+  const fields = {};
+  let inMetadata = false;
+  let metadataVersion;
+  for (const line of fmBlock.split("\n")) {
+    const trimmed = line.trimEnd();
+    if (trimmed === "metadata:") {
+      inMetadata = true;
+      continue;
+    }
+    if (inMetadata) {
+      const nestedMatch = trimmed.match(/^\s+(\w+):\s*(.+)$/);
+      if (nestedMatch) {
+        if (nestedMatch[1] === "version") {
+          metadataVersion = nestedMatch[2].trim();
+        }
+        continue;
+      }
+      inMetadata = false;
+    }
+    const kvMatch = trimmed.match(/^(\w+):\s*(.+)$/);
+    if (kvMatch) {
+      fields[kvMatch[1]] = kvMatch[2].trim();
+    }
+  }
+  const name = fields["name"];
+  const description = fields["description"];
+  if (!name || !description) return null;
+  return {
+    id: dirName,
+    name,
+    description,
+    version: metadataVersion,
+    path: filePath
+  };
+}
+
+// src/diff.ts
+function diffCards(oldCard, newCard) {
+  const fields = [];
+  const scalarFields = [
+    "protocolVersion",
+    "name",
+    "description",
+    "version",
+    "url",
+    "publicKey",
+    "iconUrl",
+    "documentationUrl"
+  ];
+  for (const field of scalarFields) {
+    const oldVal = oldCard[field];
+    const newVal = newCard[field];
+    if (oldVal !== newVal) {
+      fields.push({ field, old: oldVal, new: newVal });
+    }
+  }
+  const oldProvider = JSON.stringify(oldCard.provider ?? null);
+  const newProvider = JSON.stringify(newCard.provider ?? null);
+  if (oldProvider !== newProvider) {
+    fields.push({ field: "provider", old: oldCard.provider, new: newCard.provider });
+  }
+  const arrayFields = [
+    "defaultInputModes",
+    "defaultOutputModes"
+  ];
+  for (const field of arrayFields) {
+    const oldArr = JSON.stringify(oldCard[field]);
+    const newArr = JSON.stringify(newCard[field]);
+    if (oldArr !== newArr) {
+      fields.push({ field, old: oldCard[field], new: newCard[field] });
+    }
+  }
+  const oldSkillMap = new Map(oldCard.skills.map((s) => [s.id, s]));
+  const newSkillMap = new Map(newCard.skills.map((s) => [s.id, s]));
+  const skillsAdded = [];
+  const skillsRemoved = [];
+  const skillsModified = [];
+  for (const [id] of newSkillMap) {
+    if (!oldSkillMap.has(id)) {
+      skillsAdded.push(id);
+    }
+  }
+  for (const [id] of oldSkillMap) {
+    if (!newSkillMap.has(id)) {
+      skillsRemoved.push(id);
+    }
+  }
+  for (const [id, newSkill] of newSkillMap) {
+    const oldSkill = oldSkillMap.get(id);
+    if (oldSkill && !skillsEqual(oldSkill, newSkill)) {
+      skillsModified.push(id);
+    }
+  }
+  const changed = fields.length > 0 || skillsAdded.length > 0 || skillsRemoved.length > 0 || skillsModified.length > 0;
+  return { changed, fields, skillsAdded, skillsRemoved, skillsModified };
+}
+function formatDiff(diff2) {
+  if (!diff2.changed) {
+    return "No changes.";
+  }
+  const lines = [];
+  for (const fd of diff2.fields) {
+    const oldStr = formatValue(fd.old);
+    const newStr = formatValue(fd.new);
+    lines.push(`  ${fd.field}:`);
+    lines.push(`\x1B[31m    - ${oldStr}\x1B[0m`);
+    lines.push(`\x1B[32m    + ${newStr}\x1B[0m`);
+  }
+  for (const id of diff2.skillsAdded) {
+    lines.push(`\x1B[32m  + skill: ${id}\x1B[0m`);
+  }
+  for (const id of diff2.skillsRemoved) {
+    lines.push(`\x1B[31m  - skill: ${id}\x1B[0m`);
+  }
+  for (const id of diff2.skillsModified) {
+    lines.push(`\x1B[33m  ~ skill: ${id} (modified)\x1B[0m`);
+  }
+  return lines.join("\n");
+}
+function skillsEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function formatValue(val) {
+  if (val === void 0) return "(unset)";
+  if (val === null) return "(null)";
+  if (typeof val === "string") return val;
+  return JSON.stringify(val);
+}
+
+// src/remote.ts
+var API_BASE = "https://api.newtype-ai.org";
+async function pushBranch(nitDir, remoteName, branch2, cardJson, commitHash) {
+  const credential = await getRemoteCredential(nitDir, remoteName);
+  if (!credential) {
+    return {
+      branch: branch2,
+      commitHash,
+      remoteUrl: API_BASE,
+      success: false,
+      error: `No credential configured for remote "${remoteName}". Run: nit remote`
+    };
+  }
+  const url = `${API_BASE}/agent-card/branches/${encodeURIComponent(branch2)}`;
+  try {
+    const res = await fetch(url, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${credential}`
+      },
+      body: JSON.stringify({ card_json: cardJson, commit_hash: commitHash })
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      return {
+        branch: branch2,
+        commitHash,
+        remoteUrl: API_BASE,
+        success: false,
+        error: `HTTP ${res.status}: ${body}`
+      };
+    }
+    return { branch: branch2, commitHash, remoteUrl: API_BASE, success: true };
+  } catch (err) {
+    return {
+      branch: branch2,
+      commitHash,
+      remoteUrl: API_BASE,
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function fetchBranchCard(cardUrl, branch2, nitDir) {
+  const baseUrl = cardUrl.replace(/\/$/, "");
+  let url = `${baseUrl}/.well-known/agent-card.json`;
+  if (branch2 !== "main") {
+    url += `?branch=${encodeURIComponent(branch2)}`;
+  }
+  const res = await fetch(url);
+  if (res.ok) {
+    return await res.json();
+  }
+  if (res.status === 401 && branch2 !== "main") {
+    if (!nitDir) {
+      throw new Error(
+        `Branch "${branch2}" requires authentication. Provide nitDir for signing.`
+      );
+    }
+    const challengeData = await res.json();
+    const signature = await signChallenge(nitDir, challengeData.challenge);
+    const authRes = await fetch(url, {
+      headers: {
+        "X-Nit-Challenge": challengeData.challenge,
+        "X-Nit-Signature": signature
+      }
+    });
+    if (!authRes.ok) {
+      const body = await authRes.text();
+      throw new Error(
+        `Failed to fetch branch "${branch2}" after challenge: HTTP ${authRes.status} ${body}`
+      );
+    }
+    return await authRes.json();
+  }
+  throw new Error(`Failed to fetch card: HTTP ${res.status}`);
+}
+
+// src/index.ts
+var NIT_DIR = ".nit";
+var CARD_FILE = "agent-card.json";
+function findNitDir(startDir) {
+  let dir = resolve(startDir || process.cwd());
+  while (true) {
+    const candidate = join6(dir, NIT_DIR);
+    try {
+      const s = statSync(candidate);
+      if (s.isDirectory()) return candidate;
+    } catch {
+    }
+    const parent = resolve(dir, "..");
+    if (parent === dir) {
+      throw new Error(
+        "Not a nit repository (or any parent directory). Run `nit init` first."
+      );
+    }
+    dir = parent;
+  }
+}
+function projectDir(nitDir) {
+  return resolve(nitDir, "..");
+}
+async function readWorkingCard(nitDir) {
+  const cardPath = join6(projectDir(nitDir), CARD_FILE);
+  try {
+    const raw = await fs6.readFile(cardPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(`Cannot read ${CARD_FILE}. Does it exist?`);
+  }
+}
+async function writeWorkingCard(nitDir, card) {
+  const cardPath = join6(projectDir(nitDir), CARD_FILE);
+  await fs6.writeFile(cardPath, JSON.stringify(card, null, 2) + "\n", "utf-8");
+}
+async function getCardAtCommit(nitDir, commitHash) {
+  const commitRaw = await readObject(nitDir, commitHash);
+  const commit2 = parseCommit(commitHash, commitRaw);
+  const cardRaw = await readObject(nitDir, commit2.card);
+  return JSON.parse(cardRaw);
+}
+async function getAuthorName(nitDir) {
+  try {
+    const card = await readWorkingCard(nitDir);
+    return card.name || basename2(projectDir(nitDir));
+  } catch {
+    return basename2(projectDir(nitDir));
+  }
+}
+async function init(options) {
+  const projDir = resolve(options?.projectDir || process.cwd());
+  const nitDir = join6(projDir, NIT_DIR);
+  try {
+    await fs6.access(nitDir);
+    throw new Error("Already initialized. .nit/ directory exists.");
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("Already")) throw err;
+  }
+  await fs6.mkdir(join6(nitDir, "objects"), { recursive: true });
+  await fs6.mkdir(join6(nitDir, "refs", "heads"), { recursive: true });
+  await fs6.mkdir(join6(nitDir, "refs", "remote"), { recursive: true });
+  await fs6.mkdir(join6(nitDir, "identity"), { recursive: true });
+  await fs6.mkdir(join6(nitDir, "logs"), { recursive: true });
+  const { publicKey: pubBase64 } = await generateKeypair(nitDir);
+  const publicKeyField = formatPublicKeyField(pubBase64);
+  const cardPath = join6(projDir, CARD_FILE);
+  let card;
+  let skillsFound = [];
+  try {
+    const raw = await fs6.readFile(cardPath, "utf-8");
+    card = JSON.parse(raw);
+    card.publicKey = publicKeyField;
+    skillsFound = card.skills.map((s) => s.id);
+  } catch {
+    const discovered = await discoverSkills(projDir);
+    skillsFound = discovered.map((s) => s.id);
+    card = {
+      protocolVersion: "0.3.0",
+      name: basename2(projDir),
+      description: `AI agent working in ${basename2(projDir)}`,
+      version: "1.0.0",
+      url: "",
+      publicKey: publicKeyField,
+      defaultInputModes: ["text/plain"],
+      defaultOutputModes: ["text/plain"],
+      skills: discovered.map((s) => ({
+        id: s.id,
+        name: s.name,
+        description: s.description
+      }))
+    };
+  }
+  await writeWorkingCard(nitDir, card);
+  const cardJson = JSON.stringify(card, null, 2);
+  const cardHash = await writeObject(nitDir, "card", cardJson);
+  const commitContent = serializeCommit({
+    card: cardHash,
+    parent: null,
+    author: card.name,
+    timestamp: Math.floor(Date.now() / 1e3),
+    message: "Initial commit"
+  });
+  const commitHash = await writeObject(nitDir, "commit", commitContent);
+  await setBranch(nitDir, "main", commitHash);
+  await setHead(nitDir, "main");
+  await fs6.writeFile(join6(nitDir, "logs", "HEAD"), "", "utf-8");
+  await fs6.writeFile(join6(nitDir, "config"), "", "utf-8");
+  return {
+    publicKey: publicKeyField,
+    cardUrl: card.url || null,
+    skillsFound
+  };
+}
+async function status(options) {
+  const nitDir = findNitDir(options?.projectDir);
+  const currentBranch = await getCurrentBranch(nitDir);
+  const pubBase64 = await loadPublicKey(nitDir);
+  const publicKey = formatPublicKeyField(pubBase64);
+  let uncommittedChanges = null;
+  try {
+    const headHash = await resolveHead(nitDir);
+    const headCard = await getCardAtCommit(nitDir, headHash);
+    const workingCard = await readWorkingCard(nitDir);
+    const d = diffCards(headCard, workingCard);
+    if (d.changed) {
+      uncommittedChanges = d;
+    }
+  } catch {
+  }
+  const branches = await listBranches(nitDir);
+  const branchStatus = [];
+  for (const b of branches) {
+    const remoteHash = await getRemoteRef(nitDir, "origin", b.name);
+    let ahead = 0;
+    if (remoteHash && remoteHash !== b.commitHash) {
+      let hash = b.commitHash;
+      while (hash && hash !== remoteHash) {
+        ahead++;
+        try {
+          const raw = await readObject(nitDir, hash);
+          const c = parseCommit(hash, raw);
+          hash = c.parent;
+        } catch {
+          break;
+        }
+      }
+    } else if (!remoteHash) {
+      let hash = b.commitHash;
+      while (hash) {
+        ahead++;
+        try {
+          const raw = await readObject(nitDir, hash);
+          const c = parseCommit(hash, raw);
+          hash = c.parent;
+        } catch {
+          break;
+        }
+      }
+    }
+    branchStatus.push({ name: b.name, ahead, behind: 0 });
+  }
+  return {
+    branch: currentBranch,
+    publicKey,
+    uncommittedChanges,
+    branches: branchStatus
+  };
+}
+async function commit(message, options) {
+  const nitDir = findNitDir(options?.projectDir);
+  const projDir = projectDir(nitDir);
+  let card = await readWorkingCard(nitDir);
+  card = await resolveSkillPointers(card, projDir);
+  await writeWorkingCard(nitDir, card);
+  const cardJson = JSON.stringify(card, null, 2);
+  const cardHash = await writeObject(nitDir, "card", cardJson);
+  const currentBranch = await getCurrentBranch(nitDir);
+  const parentHash = await getBranch(nitDir, currentBranch);
+  if (parentHash) {
+    const parentRaw = await readObject(nitDir, parentHash);
+    const parentCommit = parseCommit(parentHash, parentRaw);
+    if (parentCommit.card === cardHash) {
+      throw new Error("Nothing to commit \u2014 agent card is unchanged.");
+    }
+  }
+  const author = await getAuthorName(nitDir);
+  const commitContent = serializeCommit({
+    card: cardHash,
+    parent: parentHash,
+    author,
+    timestamp: Math.floor(Date.now() / 1e3),
+    message
+  });
+  const commitHash = await writeObject(nitDir, "commit", commitContent);
+  await setBranch(nitDir, currentBranch, commitHash);
+  return {
+    type: "commit",
+    hash: commitHash,
+    card: cardHash,
+    parent: parentHash,
+    author,
+    timestamp: Math.floor(Date.now() / 1e3),
+    message
+  };
+}
+async function log(options) {
+  const nitDir = findNitDir(options?.projectDir);
+  const currentBranch = await getCurrentBranch(nitDir);
+  let hash = await getBranch(nitDir, currentBranch);
+  const commits = [];
+  const limit = options?.count ?? 50;
+  while (hash && commits.length < limit) {
+    const raw = await readObject(nitDir, hash);
+    const c = parseCommit(hash, raw);
+    commits.push(c);
+    hash = c.parent;
+  }
+  return commits;
+}
+async function diff(target, options) {
+  const nitDir = findNitDir(options?.projectDir);
+  if (!target) {
+    const headHash2 = await resolveHead(nitDir);
+    const headCard2 = await getCardAtCommit(nitDir, headHash2);
+    const workingCard = await readWorkingCard(nitDir);
+    return diffCards(headCard2, workingCard);
+  }
+  const targetBranchHash = await getBranch(nitDir, target);
+  const headHash = await resolveHead(nitDir);
+  const headCard = await getCardAtCommit(nitDir, headHash);
+  if (targetBranchHash) {
+    const targetCard = await getCardAtCommit(nitDir, targetBranchHash);
+    return diffCards(headCard, targetCard);
+  }
+  if (/^[0-9a-f]{64}$/.test(target)) {
+    const targetCard = await getCardAtCommit(nitDir, target);
+    return diffCards(headCard, targetCard);
+  }
+  throw new Error(
+    `Unknown target "${target}". Provide a branch name or commit hash.`
+  );
+}
+async function branch(name, options) {
+  const nitDir = findNitDir(options?.projectDir);
+  if (name) {
+    const existing = await getBranch(nitDir, name);
+    if (existing) {
+      throw new Error(`Branch "${name}" already exists.`);
+    }
+    const headHash = await resolveHead(nitDir);
+    await setBranch(nitDir, name, headHash);
+  }
+  return listBranches(nitDir);
+}
+async function checkout(branchName, options) {
+  const nitDir = findNitDir(options?.projectDir);
+  try {
+    const headHash = await resolveHead(nitDir);
+    const headCard = await getCardAtCommit(nitDir, headHash);
+    const workingCard = await readWorkingCard(nitDir);
+    const d = diffCards(headCard, workingCard);
+    if (d.changed) {
+      throw new Error(
+        "You have uncommitted changes. Commit or discard them before switching branches."
+      );
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("uncommitted changes")) {
+      throw err;
+    }
+  }
+  const targetHash = await getBranch(nitDir, branchName);
+  if (!targetHash) {
+    throw new Error(`Branch "${branchName}" does not exist.`);
+  }
+  const targetCard = await getCardAtCommit(nitDir, targetHash);
+  await writeWorkingCard(nitDir, targetCard);
+  await setHead(nitDir, branchName);
+}
+async function push(options) {
+  const nitDir = findNitDir(options?.projectDir);
+  const remoteName = options?.remoteName || "origin";
+  const branches = await listBranches(nitDir);
+  const currentBranch = await getCurrentBranch(nitDir);
+  const toPush = options?.all ? branches : branches.filter((b) => b.name === currentBranch);
+  if (toPush.length === 0) {
+    throw new Error("No branches to push.");
+  }
+  const results = [];
+  for (const b of toPush) {
+    const commitRaw = await readObject(nitDir, b.commitHash);
+    const c = parseCommit(b.commitHash, commitRaw);
+    const cardJson = await readObject(nitDir, c.card);
+    const result = await pushBranch(
+      nitDir,
+      remoteName,
+      b.name,
+      cardJson,
+      b.commitHash
+    );
+    if (result.success) {
+      await setRemoteRef(nitDir, remoteName, b.name, b.commitHash);
+    }
+    results.push(result);
+  }
+  return results;
+}
+async function remote(options) {
+  const nitDir = findNitDir(options?.projectDir);
+  const card = await readWorkingCard(nitDir);
+  const credential = await getRemoteCredential(nitDir, "origin");
+  return {
+    name: "origin",
+    url: card.url || "(not set)",
+    hasCredential: credential !== null
+  };
+}
+
+export {
+  formatPublicKeyField,
+  parsePublicKeyField,
+  signChallenge,
+  verifySignature,
+  diffCards,
+  formatDiff,
+  fetchBranchCard,
+  findNitDir,
+  init,
+  status,
+  commit,
+  log,
+  diff,
+  branch,
+  checkout,
+  push,
+  remote
+};