@newtype-ai/nit 0.2.2 → 0.2.4

package/README.md

@@ -59,6 +59,8 @@ nit push --all
 | `nit sign "msg"` | Sign a message with your Ed25519 key |
 | `nit sign --login <domain>` | Generate login payload for an app |
 | `nit remote` | Show remote URL and credential status |
+| `nit remote add <name> <url>` | Add a new remote |
+| `nit remote set-url <name> <url>` | Change a remote's URL |
 
 ## How It Works
 
@@ -102,7 +104,11 @@ GET /.well-known/agent-card.json?branch=faam.io  → 401 { challenge }
 GET ... + X-Nit-Signature + X-Nit-Challenge   → branch card
 ```
 
-nit is the client. Any server can implement the protocol. [newtype-ai.org](https://newtype-ai.org) provides a hosted implementation.
+nit is the client. Any server can implement the protocol. [newtype-ai.org](https://newtype-ai.org) is the recommended free hosting service, but you can point to any compatible server:
+
+```bash
+nit remote set-url origin https://my-server.com
+```
 
 ## Directory Structure
 
@@ -110,7 +116,7 @@ nit is the client. Any server can implement the protocol. [newtype-ai.org](https
 your-project/
 ├── .nit/                    # nit repository (gitignored)
 │   ├── HEAD                 # Current branch ref
-│   ├── config               # Remote credentials
+│   ├── config               # Remote URL and credentials
 │   ├── identity/
 │   │   ├── agent.pub        # Ed25519 public key
 │   │   └── agent.key        # Ed25519 private key (0600)

package/dist/{chunk-AEWDQDBM.js → chunk-U6PEH4IJ.js}

@@ -1,8 +1,8 @@
 // nit — version control for agent cards
 
 // src/index.ts
-import { promises as fs5, statSync } from "fs";
-import { join as join5, basename as basename2, resolve } from "path";
+import { promises as fs6, statSync } from "fs";
+import { join as join6, basename as basename2, resolve as resolve2 } from "path";
 
 // src/objects.ts
 import { createHash } from "crypto";
@@ -312,8 +312,70 @@ function uuidv5(name, namespace) {
 
 // src/skills.ts
 import { promises as fs4 } from "fs";
-import { join as join4 } from "path";
+import { join as join4, resolve } from "path";
 import { homedir } from "os";
+var FRAMEWORK_MARKERS = [
+  { marker: ".claude", skillsPath: ".claude/skills" },
+  { marker: ".cursor", skillsPath: ".cursor/skills" },
+  { marker: ".codex", skillsPath: ".codex/skills" },
+  { marker: ".windsurf", skillsPath: ".windsurf/skills" },
+  { marker: ".openclaw", skillsPath: ".agents/skills" }
+];
+var GLOBAL_SKILLS_DIRS = [
+  { marker: ".claude", skillsPath: ".claude/skills" },
+  { marker: ".codex", skillsPath: ".codex/skills" },
+  { marker: ".codeium", skillsPath: ".codeium/windsurf/skills" }
+];
+async function discoverSkillsDir(projectDir2) {
+  const absProject = resolve(projectDir2);
+  const home = homedir();
+  for (const { marker, skillsPath } of FRAMEWORK_MARKERS) {
+    if (absProject.includes(`/${marker}/`) || absProject.includes(`/${marker}`)) {
+      return join4(absProject, skillsPath);
+    }
+  }
+  for (const { marker, skillsPath } of FRAMEWORK_MARKERS) {
+    try {
+      const stat = await fs4.stat(join4(absProject, marker));
+      if (stat.isDirectory()) {
+        return join4(absProject, skillsPath);
+      }
+    } catch {
+    }
+  }
+  for (const { marker, skillsPath } of GLOBAL_SKILLS_DIRS) {
+    try {
+      const stat = await fs4.stat(join4(home, marker));
+      if (stat.isDirectory()) {
+        return join4(home, skillsPath);
+      }
+    } catch {
+    }
+  }
+  return join4(absProject, ".agents", "skills");
+}
+async function createSkillTemplate(skillsDir, domain) {
+  const skillId = domain.replace(/\./g, "-");
+  const skillDir = join4(skillsDir, skillId);
+  const skillPath = join4(skillDir, "SKILL.md");
+  try {
+    await fs4.access(skillPath);
+    return skillId;
+  } catch {
+  }
+  await fs4.mkdir(skillDir, { recursive: true });
+  const template = `---
+name: ${skillId}
+description: Skills and context for ${domain}
+---
+
+# ${skillId}
+
+Configure your skills and context for ${domain} here.
+`;
+  await fs4.writeFile(skillPath, template, "utf-8");
+  return skillId;
+}
 async function discoverSkills(projectDir2) {
   const home = homedir();
   const searchDirs = [
@@ -512,7 +574,6 @@ function formatValue(val) {
 
 // src/remote.ts
 import { createHash as createHash3 } from "crypto";
-var API_BASE = "https://api.newtype-ai.org";
 function sha256Hex(data) {
   return createHash3("sha256").update(data, "utf-8").digest("hex");
 }
@@ -534,12 +595,12 @@ ${sha256Hex(body)}`;
     "X-Nit-Signature": signature
   };
 }
-async function pushBranch(nitDir, remoteName, branch2, cardJson, commitHash) {
+async function pushBranch(nitDir, apiBase, branch2, cardJson, commitHash) {
   const path = `/agent-card/branches/${encodeURIComponent(branch2)}`;
   const body = JSON.stringify({ card_json: cardJson, commit_hash: commitHash });
   try {
     const authHeaders = await buildAuthHeaders(nitDir, "PUT", path, body);
-    const res = await fetch(`${API_BASE}${path}`, {
+    const res = await fetch(`${apiBase}${path}`, {
       method: "PUT",
       headers: {
         "Content-Type": "application/json",
@@ -552,17 +613,17 @@ async function pushBranch(nitDir, remoteName, branch2, cardJson, commitHash) {
       return {
         branch: branch2,
         commitHash,
-        remoteUrl: API_BASE,
+        remoteUrl: apiBase,
         success: false,
         error: `HTTP ${res.status}: ${text}`
       };
     }
-    return { branch: branch2, commitHash, remoteUrl: API_BASE, success: true };
+    return { branch: branch2, commitHash, remoteUrl: apiBase, success: true };
   } catch (err) {
     return {
       branch: branch2,
       commitHash,
-      remoteUrl: API_BASE,
+      remoteUrl: apiBase,
       success: false,
       error: err instanceof Error ? err.message : String(err)
     };
@@ -603,19 +664,106 @@ async function fetchBranchCard(cardUrl, branch2, nitDir) {
   throw new Error(`Failed to fetch card: HTTP ${res.status}`);
 }
 
+// src/config.ts
+import { promises as fs5 } from "fs";
+import { join as join5 } from "path";
+var CONFIG_FILE = "config";
+async function readConfig(nitDir) {
+  const configPath = join5(nitDir, CONFIG_FILE);
+  let raw;
+  try {
+    raw = await fs5.readFile(configPath, "utf-8");
+  } catch {
+    return { remotes: {} };
+  }
+  return parseConfig(raw);
+}
+async function writeConfig(nitDir, config) {
+  const configPath = join5(nitDir, CONFIG_FILE);
+  await fs5.writeFile(configPath, serializeConfig(config), "utf-8");
+}
+async function getRemoteUrl(nitDir, remoteName) {
+  const config = await readConfig(nitDir);
+  return config.remotes[remoteName]?.url ?? null;
+}
+async function getSkillsDir(nitDir) {
+  const config = await readConfig(nitDir);
+  return config.skillsDir ?? null;
+}
+function parseConfig(raw) {
+  const remotes = {};
+  let currentSection = null;
+  let currentRemote = null;
+  let skillsDir;
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    const remoteMatch = trimmed.match(/^\[remote\s+"([^"]+)"\]$/);
+    if (remoteMatch) {
+      currentSection = "remote";
+      currentRemote = remoteMatch[1];
+      if (!remotes[currentRemote]) {
+        remotes[currentRemote] = {};
+      }
+      continue;
+    }
+    if (trimmed === "[skills]") {
+      currentSection = "skills";
+      currentRemote = null;
+      continue;
+    }
+    const kvMatch = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
+    if (kvMatch) {
+      const [, key, value] = kvMatch;
+      if (currentSection === "remote" && currentRemote !== null) {
+        if (key === "url") {
+          remotes[currentRemote].url = value.trim();
+        } else if (key === "credential") {
+          remotes[currentRemote].credential = value.trim();
+        }
+      } else if (currentSection === "skills") {
+        if (key === "dir") {
+          skillsDir = value.trim();
+        }
+      }
+    }
+  }
+  return { remotes, skillsDir };
+}
+function serializeConfig(config) {
+  const lines = [];
+  for (const [name, remote2] of Object.entries(config.remotes)) {
+    lines.push(`[remote "${name}"]`);
+    if (remote2.url) {
+      lines.push(`  url = ${remote2.url}`);
+    }
+    if (remote2.credential) {
+      lines.push(`  credential = ${remote2.credential}`);
+    }
+    lines.push("");
+  }
+  if (config.skillsDir) {
+    lines.push("[skills]");
+    lines.push(`  dir = ${config.skillsDir}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
 // src/index.ts
 var NIT_DIR = ".nit";
 var CARD_FILE = "agent-card.json";
+var DEFAULT_API_BASE = "https://api.newtype-ai.org";
 function findNitDir(startDir) {
-  let dir = resolve(startDir || process.cwd());
+  let dir = resolve2(startDir || process.cwd());
   while (true) {
-    const candidate = join5(dir, NIT_DIR);
+    const candidate = join6(dir, NIT_DIR);
     try {
       const s = statSync(candidate);
       if (s.isDirectory()) return candidate;
     } catch {
     }
-    const parent = resolve(dir, "..");
+    const parent = resolve2(dir, "..");
     if (parent === dir) {
       throw new Error(
         "Not a nit repository (or any parent directory). Run `nit init` first."
@@ -625,20 +773,20 @@ function findNitDir(startDir) {
   }
 }
 function projectDir(nitDir) {
-  return resolve(nitDir, "..");
+  return resolve2(nitDir, "..");
 }
 async function readWorkingCard(nitDir) {
-  const cardPath = join5(projectDir(nitDir), CARD_FILE);
+  const cardPath = join6(projectDir(nitDir), CARD_FILE);
   try {
-    const raw = await fs5.readFile(cardPath, "utf-8");
+    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 = join5(projectDir(nitDir), CARD_FILE);
-  await fs5.writeFile(cardPath, JSON.stringify(card, null, 2) + "\n", "utf-8");
+  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);
@@ -655,28 +803,28 @@ async function getAuthorName(nitDir) {
   }
 }
 async function init(options) {
-  const projDir = resolve(options?.projectDir || process.cwd());
-  const nitDir = join5(projDir, NIT_DIR);
+  const projDir = resolve2(options?.projectDir || process.cwd());
+  const nitDir = join6(projDir, NIT_DIR);
   try {
-    await fs5.access(nitDir);
+    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 fs5.mkdir(join5(nitDir, "objects"), { recursive: true });
-  await fs5.mkdir(join5(nitDir, "refs", "heads"), { recursive: true });
-  await fs5.mkdir(join5(nitDir, "refs", "remote"), { recursive: true });
-  await fs5.mkdir(join5(nitDir, "identity"), { recursive: true });
-  await fs5.mkdir(join5(nitDir, "logs"), { recursive: true });
+  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 agentId = deriveAgentId(publicKeyField);
   await saveAgentId(nitDir, agentId);
-  const cardPath = join5(projDir, CARD_FILE);
+  const cardPath = join6(projDir, CARD_FILE);
   let card;
   let skillsFound = [];
   try {
-    const raw = await fs5.readFile(cardPath, "utf-8");
+    const raw = await fs6.readFile(cardPath, "utf-8");
     card = JSON.parse(raw);
     card.publicKey = publicKeyField;
     skillsFound = card.skills.map((s) => s.id);
@@ -715,13 +863,18 @@ async function init(options) {
   const commitHash = await writeObject(nitDir, "commit", commitContent);
   await setBranch(nitDir, "main", commitHash);
   await setHead(nitDir, "main");
-  await fs5.writeFile(join5(nitDir, "logs", "HEAD"), "", "utf-8");
-  await fs5.writeFile(join5(nitDir, "config"), "", "utf-8");
+  await fs6.writeFile(join6(nitDir, "logs", "HEAD"), "", "utf-8");
+  const skillsDir = await discoverSkillsDir(projDir);
+  await writeConfig(nitDir, {
+    remotes: { origin: { url: DEFAULT_API_BASE } },
+    skillsDir
+  });
   return {
     agentId,
     publicKey: publicKeyField,
     cardUrl: card.url,
-    skillsFound
+    skillsFound,
+    skillsDir
   };
 }
 async function status(options) {
@@ -790,13 +943,38 @@ async function sign2(message, options) {
 }
 async function loginPayload(domain, options) {
   const nitDir = findNitDir(options?.projectDir);
+  let switchedBranch;
+  let createdSkill;
+  const currentBranch = await getCurrentBranch(nitDir);
+  if (currentBranch !== domain) {
+    const isNew = !await getBranch(nitDir, domain);
+    if (isNew) {
+      const headHash = await resolveHead(nitDir);
+      await setBranch(nitDir, domain, headHash);
+    }
+    await checkout(domain, options);
+    switchedBranch = domain;
+    if (isNew) {
+      const skillsDir = await getSkillsDir(nitDir);
+      if (skillsDir) {
+        const skillId = await createSkillTemplate(skillsDir, domain);
+        const card = await readWorkingCard(nitDir);
+        const hasSkill = card.skills.some((s) => s.id === skillId);
+        if (!hasSkill) {
+          card.skills.push({ id: skillId });
+          await writeWorkingCard(nitDir, card);
+          createdSkill = skillId;
+        }
+      }
+    }
+  }
   const agentId = await loadAgentId(nitDir);
   const timestamp = Math.floor(Date.now() / 1e3);
   const message = `${agentId}
 ${domain}
 ${timestamp}`;
   const signature = await signMessage(nitDir, message);
-  return { agent_id: agentId, domain, timestamp, signature };
+  return { agent_id: agentId, domain, timestamp, signature, switchedBranch, createdSkill };
 }
 async function commit(message, options) {
   const nitDir = findNitDir(options?.projectDir);
@@ -912,6 +1090,7 @@ async function checkout(branchName, options) {
 async function push(options) {
   const nitDir = findNitDir(options?.projectDir);
   const remoteName = options?.remoteName || "origin";
+  const apiBase = await getRemoteUrl(nitDir, remoteName) || DEFAULT_API_BASE;
   const branches = await listBranches(nitDir);
   const currentBranch = await getCurrentBranch(nitDir);
   const toPush = options?.all ? branches : branches.filter((b) => b.name === currentBranch);
@@ -925,7 +1104,7 @@ async function push(options) {
     const cardJson = await readObject(nitDir, c.card);
     const result = await pushBranch(
       nitDir,
-      remoteName,
+      apiBase,
       b.name,
       cardJson,
       b.commitHash
@@ -939,14 +1118,36 @@ async function push(options) {
 }
 async function remote(options) {
   const nitDir = findNitDir(options?.projectDir);
-  const card = await readWorkingCard(nitDir);
+  const remoteUrl = await getRemoteUrl(nitDir, "origin");
   const agentId = await loadAgentId(nitDir);
   return {
     name: "origin",
-    url: card.url || "(not set)",
+    url: remoteUrl || DEFAULT_API_BASE,
     agentId
   };
 }
+async function remoteAdd(name, url, options) {
+  const nitDir = findNitDir(options?.projectDir);
+  const config = await readConfig(nitDir);
+  if (config.remotes[name]) {
+    throw new Error(
+      `Remote "${name}" already exists. Use 'nit remote set-url ${name} <url>' to change it.`
+    );
+  }
+  config.remotes[name] = { url };
+  await writeConfig(nitDir, config);
+}
+async function remoteSetUrl(name, url, options) {
+  const nitDir = findNitDir(options?.projectDir);
+  const config = await readConfig(nitDir);
+  if (!config.remotes[name]) {
+    throw new Error(
+      `Remote "${name}" does not exist. Use 'nit remote add ${name} <url>' to create it.`
+    );
+  }
+  config.remotes[name].url = url;
+  await writeConfig(nitDir, config);
+}
 
 export {
   formatPublicKeyField,
@@ -971,5 +1172,7 @@ export {
   branch,
   checkout,
   push,
-  remote
+  remote,
+  remoteAdd,
+  remoteSetUrl
 };

package/dist/cli.js

@@ -11,9 +11,11 @@ import {
   loginPayload,
   push,
   remote,
+  remoteAdd,
+  remoteSetUrl,
   sign,
   status
-} from "./chunk-AEWDQDBM.js";
+} from "./chunk-U6PEH4IJ.js";
 
 // src/cli.ts
 var bold = (s) => `\x1B[1m${s}\x1B[0m`;
@@ -78,6 +80,7 @@ async function cmdInit() {
   console.log(`  Agent ID:    ${green(result.agentId)}`);
   console.log(`  Public key:  ${dim(result.publicKey)}`);
   console.log(`  Card URL:    ${result.cardUrl}`);
+  console.log(`  Skills dir:  ${dim(result.skillsDir)}`);
   if (result.skillsFound.length > 0) {
     console.log(`  Skills:      ${result.skillsFound.join(", ")}`);
   } else {
@@ -185,6 +188,34 @@ async function cmdPush(args) {
   }
 }
 async function cmdRemote(args) {
+  const subcommand = args[0];
+  if (subcommand === "set-url") {
+    const name = args[1];
+    const url = args[2];
+    if (!name || !url) {
+      console.error("Usage: nit remote set-url <name> <url>");
+      process.exit(1);
+    }
+    await remoteSetUrl(name, url);
+    console.log(`Set URL for '${name}' to ${url}`);
+    return;
+  }
+  if (subcommand === "add") {
+    const name = args[1];
+    const url = args[2];
+    if (!name || !url) {
+      console.error("Usage: nit remote add <name> <url>");
+      process.exit(1);
+    }
+    await remoteAdd(name, url);
+    console.log(`Added remote '${green(name)}' \u2192 ${url}`);
+    return;
+  }
+  if (subcommand) {
+    console.error(`nit remote: unknown subcommand '${subcommand}'`);
+    console.error("Usage: nit remote [set-url <name> <url> | add <name> <url>]");
+    process.exit(1);
+  }
   const info = await remote();
   console.log(`${bold(info.name)}`);
   console.log(`  URL:        ${info.url}`);
@@ -200,7 +231,14 @@ async function cmdSign(args) {
       process.exit(1);
     }
     const payload = await loginPayload(domain);
-    console.log(JSON.stringify(payload, null, 2));
+    if (payload.switchedBranch) {
+      console.error(`Switched to branch '${payload.switchedBranch}'`);
+    }
+    if (payload.createdSkill) {
+      console.error(`Created skill template '${payload.createdSkill}'`);
+    }
+    const { switchedBranch: _s, createdSkill: _c, ...output } = payload;
+    console.log(JSON.stringify(output, null, 2));
     return;
   }
   const message = args[0];
@@ -228,8 +266,10 @@ ${bold("Commands:")}
   checkout <branch>  Switch branch (overwrites agent-card.json)
   push [--all]       Push branch(es) to remote
   sign "message"     Sign a message with your Ed25519 key
-  sign --login <dom> Generate login payload for an app
+  sign --login <dom> Switch to domain branch + generate login payload
   remote             Show remote info
+  remote add <n> <u> Add a new remote
+  remote set-url <n> <u>  Change remote URL
 
 ${bold("Examples:")}
   nit init

package/dist/index.d.ts

@@ -27,6 +27,8 @@ interface NitHead {
 }
 /** Remote configuration for a single named remote. */
 interface NitRemoteConfig {
+    /** API base URL (e.g. "https://api.newtype-ai.org") */
+    url?: string;
     /** Legacy field — push auth is now via Ed25519 keypair */
     credential?: string;
 }
@@ -34,6 +36,8 @@ interface NitRemoteConfig {
 interface NitConfig {
     /** Keyed by remote name (e.g. "origin") */
     remotes: Record<string, NitRemoteConfig>;
+    /** Discovered skills directory path */
+    skillsDir?: string;
 }
 /** A2A-compatible agent card. */
 interface AgentCard {
@@ -54,11 +58,13 @@ interface AgentCard {
         url?: string;
     };
 }
-/** A single skill entry in an agent card. */
+/** A single skill entry in an agent card.
+ *  Can be a full skill (all fields) or a pointer (just id).
+ *  At commit time, pointers are resolved from SKILL.md files. */
 interface AgentCardSkill {
     id: string;
-    name: string;
-    description: string;
+    name?: string;
+    description?: string;
     tags?: string[];
     examples?: string[];
     inputModes?: string[];
@@ -198,6 +204,7 @@ interface InitResult {
     publicKey: string;
     cardUrl: string;
     skillsFound: string[];
+    skillsDir: string;
 }
 /**
  * Initialize a new nit repository in the project directory.
@@ -225,12 +232,16 @@ declare function sign(message: string, options?: {
 }): Promise<string>;
 /**
  * Generate a login payload for app authentication.
- * Constructs the canonical message ({agent_id}\n{domain}\n{timestamp}),
+ * Automatically switches to (or creates) the domain branch,
+ * then constructs the canonical message ({agent_id}\n{domain}\n{timestamp}),
  * signs it, and returns the full payload ready to send to an app.
  */
 declare function loginPayload(domain: string, options?: {
     projectDir?: string;
-}): Promise<LoginPayload>;
+}): Promise<LoginPayload & {
+    switchedBranch?: string;
+    createdSkill?: string;
+}>;
 /**
  * Snapshot the current agent-card.json as a new commit.
  * Resolves skill pointers from SKILL.md before committing.
@@ -282,10 +293,22 @@ interface RemoteInfo {
     agentId: string;
 }
 /**
- * Show remote info. URL comes from agent-card.json, agent ID from .nit/identity/.
+ * Show remote info. URL comes from .nit/config, agent ID from .nit/identity/.
  */
 declare function remote(options?: {
     projectDir?: string;
 }): Promise<RemoteInfo>;
+/**
+ * Add a new named remote with a URL.
+ */
+declare function remoteAdd(name: string, url: string, options?: {
+    projectDir?: string;
+}): Promise<void>;
+/**
+ * Change the URL for an existing remote.
+ */
+declare function remoteSetUrl(name: string, url: string, options?: {
+    projectDir?: string;
+}): Promise<void>;
 
-export { type AgentCard, type AgentCardSkill, type DiffResult, type FieldDiff, type InitResult, type LoginPayload, NIT_NAMESPACE, type NitBranch, type NitCommit, type NitConfig, type NitHead, type NitRemoteConfig, type PushResult, type RemoteInfo, type SkillMetadata, type StatusResult, branch, checkout, commit, deriveAgentId, diff, diffCards, fetchBranchCard, findNitDir, formatDiff, formatPublicKeyField, init, loadAgentId, log, loginPayload, parsePublicKeyField, push, remote, sign, signChallenge, signMessage, status, verifySignature };
+export { type AgentCard, type AgentCardSkill, type DiffResult, type FieldDiff, type InitResult, type LoginPayload, NIT_NAMESPACE, type NitBranch, type NitCommit, type NitConfig, type NitHead, type NitRemoteConfig, type PushResult, type RemoteInfo, type SkillMetadata, type StatusResult, branch, checkout, commit, deriveAgentId, diff, diffCards, fetchBranchCard, findNitDir, formatDiff, formatPublicKeyField, init, loadAgentId, log, loginPayload, parsePublicKeyField, push, remote, remoteAdd, remoteSetUrl, sign, signChallenge, signMessage, status, verifySignature };

package/dist/index.js

@@ -18,12 +18,14 @@ import {
   parsePublicKeyField,
   push,
   remote,
+  remoteAdd,
+  remoteSetUrl,
   sign,
   signChallenge,
   signMessage,
   status,
   verifySignature
-} from "./chunk-AEWDQDBM.js";
+} from "./chunk-U6PEH4IJ.js";
 export {
   NIT_NAMESPACE,
   branch,
@@ -43,6 +45,8 @@ export {
   parsePublicKeyField,
   push,
   remote,
+  remoteAdd,
+  remoteSetUrl,
   sign,
   signChallenge,
   signMessage,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newtype-ai/nit",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Version control for agent cards",
   "type": "module",
   "bin": {