@morphllm/gitmorph-sdk 0.2.1 → 0.3.0

package/dist/chunk-JXXUBMF6.js

@@ -0,0 +1,61 @@
+import { toJsonSchema, clampOutput } from './chunk-FXEX72CO.js';
+import { resolveToolSet } from './chunk-A3AOZFPE.js';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+
+function createGitmorphMcpServer(gm, opts = {}) {
+  const normalized = resolveToolSet(gm, opts);
+  const byName = new Map(normalized.map((t) => [t.name, t]));
+  const maxBytes = opts.maxOutputBytes;
+  const server = new Server(
+    { name: "gitmorph", version: "0.3.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: normalized.map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: toJsonSchema(t.schema)
+    }))
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const def = byName.get(req.params.name);
+    if (!def) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: `Unknown tool: ${req.params.name}` }]
+      };
+    }
+    const parsed = def.schema.safeParse(req.params.arguments ?? {});
+    if (!parsed.success) {
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: `Invalid input for ${req.params.name}: ${parsed.error.message}`
+          }
+        ]
+      };
+    }
+    try {
+      const result = await def.execute(parsed.data);
+      return {
+        content: [{ type: "text", text: clampOutput(result, maxBytes) }]
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { isError: true, content: [{ type: "text", text: message }] };
+    }
+  });
+  return server;
+}
+async function startGitmorphMcpServer(gm, opts) {
+  const server = createGitmorphMcpServer(gm, opts);
+  await server.connect(new StdioServerTransport());
+}
+
+export { createGitmorphMcpServer, startGitmorphMcpServer };
+//# sourceMappingURL=chunk-JXXUBMF6.js.map
+//# sourceMappingURL=chunk-JXXUBMF6.js.map

package/dist/chunk-JXXUBMF6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mcp/index.ts"],"names":[],"mappings":";;;;;;AA+BO,SAAS,uBAAA,CACd,EAAA,EACA,IAAA,GAA2B,EAAC,EACpB;AACR,EAAA,MAAM,UAAA,GAAa,cAAA,CAAe,EAAA,EAAI,IAAI,CAAA;AAC1C,EAAA,MAAM,MAAA,GAAS,IAAI,GAAA,CAAI,UAAA,CAAW,GAAA,CAAI,CAAC,CAAA,KAAM,CAAC,CAAA,CAAE,IAAA,EAAM,CAAC,CAAC,CAAC,CAAA;AACzD,EAAA,MAAM,WAAW,IAAA,CAAK,cAAA;AAEtB,EAAA,MAAM,SAAS,IAAI,MAAA;AAAA,IACjB,EAAE,IAAA,EAAM,UAAA,EAAY,OAAA,EAAS,OAAA,EAAQ;AAAA,IACrC,EAAE,YAAA,EAAc,EAAE,KAAA,EAAO,IAAG;AAAE,GAChC;AAEA,EAAA,MAAA,CAAO,iBAAA,CAAkB,wBAAwB,aAAa;AAAA,IAC5D,KAAA,EAAO,UAAA,CAAW,GAAA,CAAI,CAAC,CAAA,MAAO;AAAA,MAC5B,MAAM,CAAA,CAAE,IAAA;AAAA,MACR,aAAa,CAAA,CAAE,WAAA;AAAA,MACf,WAAA,EAAa,YAAA,CAAa,CAAA,CAAE,MAAM;AAAA,KACpC,CAAE;AAAA,GACJ,CAAE,CAAA;AAEF,EAAA,MAAA,CAAO,iBAAA,CAAkB,qBAAA,EAAuB,OAAO,GAAA,KAAQ;AAC7D,IAAA,MAAM,GAAA,GAAM,MAAA,CAAO,GAAA,CAAI,GAAA,CAAI,OAAO,IAAI,CAAA;AACtC,IAAA,IAAI,CAAC,GAAA,EAAK;AACR,MAAA,OAAO;AAAA,QACL,OAAA,EAAS,IAAA;AAAA,QACT,OAAA,EAAS,CAAC,EAAE,IAAA,EAAM,MAAA,EAAQ,IAAA,EAAM,CAAA,cAAA,EAAiB,GAAA,CAAI,MAAA,CAAO,IAAI,CAAA,CAAA,EAAI;AAAA,OACtE;AAAA,IACF;AACA,IAAA,MAAM,MAAA,GAAS,IAAI,MAAA,CAAO,SAAA,CAAU,IAAI,MAAA,CAAO,SAAA,IAAa,EAAE,CAAA;AAC9D,IAAA,IAAI,CAAC,OAAO,OAAA,EAAS;AACnB,MAAA,OAAO;AAAA,QACL,OAAA,EAAS,IAAA;AAAA,QACT,OAAA,EAAS;AAAA,UACP;AAAA,YACE,IAAA,EAAM,MAAA;AAAA,YACN,IAAA,EAAM,qBAAqB,GAAA,CAAI,MAAA,CAAO,IAAI,CAAA,EAAA,EAAK,MAAA,CAAO,MAAM,OAAO,CAAA;AAAA;AACrE;AACF,OACF;AAAA,IACF;AACA,IAAA,IAAI;AACF,MAAA,MAAM,MAAA,GAAS,MAAM,GAAA,CAAI,OAAA,CAAQ,OAAO,IAAI,CAAA;AAC5C,MAAA,OAAO;AAAA,QACL,OAAA,EAAS,CAAC,EAAE,IAAA,EAAM,MAAA,EAAQ,MAAM,WAAA,CAAY,MAAA,EAAQ,QAAQ,CAAA,EAAG;AAAA,OACjE;AAAA,IACF,SAAS,GAAA,EAAK;AACZ,MAAA,MAAM,UAAU,GAAA,YAAe,KAAA,GAAQ,GAAA,CAAI,OAAA,GAAU,OAAO,GAAG,CAAA;AAC/D,MAAA,OAAO,EAAE,OAAA,EAAS,IAAA,EAAM,OAAA,EAAS,CAAC,EAAE,IAAA,EAAM,MAAA,EAAQ,IAAA,EAAM,OAAA,EAAS,CAAA,EAAE;AAAA,IACrE;AAAA,EACF,CAAC,CAAA;AAED,EAAA,OAAO,MAAA;AACT;AAMA,eAAsB,sBAAA,CACpB,IACA,IAAA,EACe;AACf,EAAA,MAAM,MAAA,GAAS,uBAAA,CAAwB,EAAA,EAAI,IAAI,CAAA;AAC/C,EAAA,MAAM,MAAA,CAAO,OAAA,CAAQ,IAAI,oBAAA,EAAsB,CAAA;AACjD","file":"chunk-JXXUBMF6.js","sourcesContent":["import { Server } from \"@modelcontextprotocol/sdk/server/index.js\";\nimport { StdioServerTransport } from \"@modelcontextprotocol/sdk/server/stdio.js\";\nimport {\n  CallToolRequestSchema,\n  ListToolsRequestSchema,\n} from \"@modelcontextprotocol/sdk/types.js\";\nimport type { GitMorph } from \"../client.js\";\nimport { resolveToolSet, type CreateToolsOptions } from \"../tools/core.js\";\nimport { toJsonSchema } from \"../tools/json-schema.js\";\nimport { clampOutput } from \"../tools/truncate.js\";\n\nexport { GITMORPH_SYSTEM_PROMPT } from \"../tools/instructions.js\";\nexport { DEFAULT_TOOL_NAMES } from \"../tools/registry.js\";\nexport type { CreateToolsOptions } from \"../tools/core.js\";\nexport type { GitmorphToolName } from \"../tools/registry.js\";\n\n/**\n * Build an MCP server that exposes the GitMorph toolkit over stdio.\n *\n * Use this when you want to register GitMorph with any MCP-compatible client\n * (Claude Desktop, Cursor, Claude Code, etc.). For the common case, prefer\n * the shipped CLI: `npx @morphllm/gitmorph-sdk mcp`.\n *\n * @example\n * ```ts\n * import { GitMorph } from \"@morphllm/gitmorph-sdk\";\n * import { startGitmorphMcpServer } from \"@morphllm/gitmorph-sdk/mcp\";\n *\n * await startGitmorphMcpServer(new GitMorph());\n * ```\n */\nexport function createGitmorphMcpServer(\n  gm: GitMorph,\n  opts: CreateToolsOptions = {},\n): Server {\n  const normalized = resolveToolSet(gm, opts);\n  const byName = new Map(normalized.map((t) => [t.name, t]));\n  const maxBytes = opts.maxOutputBytes;\n\n  const server = new Server(\n    { name: \"gitmorph\", version: \"0.3.0\" },\n    { capabilities: { tools: {} } },\n  );\n\n  server.setRequestHandler(ListToolsRequestSchema, async () => ({\n    tools: normalized.map((t) => ({\n      name: t.name,\n      description: t.description,\n      inputSchema: toJsonSchema(t.schema),\n    })),\n  }));\n\n  server.setRequestHandler(CallToolRequestSchema, async (req) => {\n    const def = byName.get(req.params.name);\n    if (!def) {\n      return {\n        isError: true,\n        content: [{ type: \"text\", text: `Unknown tool: ${req.params.name}` }],\n      };\n    }\n    const parsed = def.schema.safeParse(req.params.arguments ?? {});\n    if (!parsed.success) {\n      return {\n        isError: true,\n        content: [\n          {\n            type: \"text\",\n            text: `Invalid input for ${req.params.name}: ${parsed.error.message}`,\n          },\n        ],\n      };\n    }\n    try {\n      const result = await def.execute(parsed.data);\n      return {\n        content: [{ type: \"text\", text: clampOutput(result, maxBytes) }],\n      };\n    } catch (err) {\n      const message = err instanceof Error ? err.message : String(err);\n      return { isError: true, content: [{ type: \"text\", text: message }] };\n    }\n  });\n\n  return server;\n}\n\n/**\n * Start an MCP stdio server for the GitMorph toolkit. Resolves when the\n * server's transport disconnects.\n */\nexport async function startGitmorphMcpServer(\n  gm: GitMorph,\n  opts?: CreateToolsOptions,\n): Promise<void> {\n  const server = createGitmorphMcpServer(gm, opts);\n  await server.connect(new StdioServerTransport());\n}\n"]}

package/dist/chunk-QT3Y4ZIS.js

@@ -0,0 +1,547 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+// src/errors.ts
+var GitMorphError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GitMorphError";
+  }
+};
+var AuthenticationError = class extends GitMorphError {
+  constructor(message) {
+    super(
+      message ?? "Not authenticated. Provide a token or configure ~/.config/gm/config.json"
+    );
+    this.name = "AuthenticationError";
+  }
+};
+var ApiError = class extends GitMorphError {
+  status;
+  url;
+  constructor(message, status, url) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+    this.url = url;
+  }
+};
+var MirrorError = class extends GitMorphError {
+  constructor(message) {
+    super(message);
+    this.name = "MirrorError";
+  }
+};
+var GrepError = class extends GitMorphError {
+  constructor(message) {
+    super(message);
+    this.name = "GrepError";
+  }
+};
+
+// src/api.ts
+function buildUrl(path, options) {
+  const baseUrl = `https://${options.host}/api/v1`;
+  const url = new URL(path.startsWith("/") ? `${baseUrl}${path}` : `${baseUrl}/${path}`);
+  if (options.params) {
+    for (const [key, value] of Object.entries(options.params)) {
+      url.searchParams.set(key, value);
+    }
+  }
+  return url;
+}
+function buildHeaders(options) {
+  const headers = {
+    Authorization: `token ${options.token}`
+  };
+  if (options.body) {
+    headers["Content-Type"] = "application/json";
+    headers["Accept"] = "application/json";
+  } else {
+    headers["Accept"] = "application/json";
+  }
+  return headers;
+}
+async function handleErrorResponse(res, url) {
+  let message = `API request failed: ${res.status}`;
+  try {
+    const body = await res.json();
+    if (body.message) message = body.message;
+  } catch {
+  }
+  throw new ApiError(message, res.status, url.toString());
+}
+async function apiRequest(method, path, options) {
+  const url = buildUrl(path, options);
+  const headers = buildHeaders(options);
+  const res = await fetch(url.toString(), {
+    method,
+    headers,
+    body: options.body ? JSON.stringify(options.body) : void 0
+  });
+  if (!res.ok) return handleErrorResponse(res, url);
+  if (res.status === 204) return void 0;
+  return await res.json();
+}
+async function apiRequestRaw(method, path, options) {
+  const url = buildUrl(path, options);
+  const headers = {
+    Authorization: `token ${options.token}`
+  };
+  const res = await fetch(url.toString(), { method, headers });
+  if (!res.ok) return handleErrorResponse(res, url);
+  return res.text();
+}
+
+// src/repo.ts
+var GitMorphRepo = class {
+  owner;
+  name;
+  auth;
+  treeCache = /* @__PURE__ */ new Map();
+  defaultRef;
+  repoId;
+  constructor(owner, name, auth) {
+    this.owner = owner;
+    this.name = name;
+    this.auth = auth;
+  }
+  async resolveRepoInfo() {
+    if (this.defaultRef && this.repoId) {
+      return { ref: this.defaultRef, id: this.repoId };
+    }
+    const info = await apiRequest(
+      "GET",
+      `/repos/${this.owner}/${this.name}`,
+      this.auth
+    );
+    this.defaultRef = info.default_branch;
+    this.repoId = info.id;
+    return { ref: this.defaultRef, id: this.repoId };
+  }
+  async resolveRef(ref) {
+    if (ref) return ref;
+    const info = await this.resolveRepoInfo();
+    return info.ref;
+  }
+  async resolveRepoId() {
+    const info = await this.resolveRepoInfo();
+    return info.id;
+  }
+  async fetchTree(ref) {
+    if (this.treeCache.has(ref)) {
+      return { entries: this.treeCache.get(ref), truncated: false };
+    }
+    const encodedRef = encodeURIComponent(ref);
+    const firstPage = await apiRequest(
+      "GET",
+      `/repos/${this.owner}/${this.name}/git/trees/${encodedRef}`,
+      { ...this.auth, params: { recursive: "true", per_page: "10000" } }
+    );
+    let allEntries = [...firstPage.tree];
+    let truncated = firstPage.truncated;
+    if (truncated && firstPage.total_count && firstPage.total_count > allEntries.length) {
+      let page = 2;
+      while (allEntries.length < firstPage.total_count) {
+        const nextPage = await apiRequest(
+          "GET",
+          `/repos/${this.owner}/${this.name}/git/trees/${encodedRef}`,
+          { ...this.auth, params: { recursive: "true", per_page: "10000", page: String(page) } }
+        );
+        if (!nextPage.tree.length) break;
+        allEntries = allEntries.concat(nextPage.tree);
+        truncated = nextPage.truncated;
+        page++;
+      }
+    }
+    this.treeCache.set(ref, allEntries);
+    return { entries: allEntries, truncated };
+  }
+  async fetchRaw(path, ref) {
+    const encodedRef = encodeURIComponent(ref);
+    return apiRequestRaw(
+      "GET",
+      `/repos/${this.owner}/${this.name}/raw/${path}`,
+      { ...this.auth, params: { ref: encodedRef } }
+    );
+  }
+  // ── readFile ──────────────────────────────────────────────────────────────
+  async readFile(path, options) {
+    const ref = await this.resolveRef(options?.ref);
+    if (options?.lines) {
+      for (const range of options.lines) {
+        if (range.start < 1) {
+          throw new GitMorphError(`LineRange.start must be >= 1, got ${range.start}`);
+        }
+        if (range.end < range.start) {
+          throw new GitMorphError(`LineRange.end (${range.end}) must be >= start (${range.start})`);
+        }
+      }
+    }
+    const rawContent = await this.fetchRaw(path, ref);
+    const allLines = rawContent.split("\n");
+    const totalLines = allLines.length;
+    if (!options?.lines) {
+      return { path, content: rawContent, totalLines };
+    }
+    const clampedRanges = [];
+    const extracted = [];
+    for (const range of options.lines) {
+      const start = Math.min(range.start, totalLines);
+      const end = Math.min(range.end, totalLines);
+      clampedRanges.push({ start, end });
+      extracted.push(allLines.slice(start - 1, end).join("\n"));
+    }
+    return {
+      path,
+      content: extracted.join("\n"),
+      totalLines,
+      lines: clampedRanges
+    };
+  }
+  // ── grep (server-side via Bleve/git-grep) ─────────────────────────────────
+  async grep(options) {
+    if (!options.pattern) {
+      throw new GrepError("pattern is required");
+    }
+    const repoId = await this.resolveRepoId();
+    const params = {
+      q: options.pattern,
+      repo_id: String(repoId)
+    };
+    if (options.language) params.l = options.language;
+    if (options.maxMatches) params.limit = String(Math.min(options.maxMatches, 50));
+    if (options.page) params.page = String(options.page);
+    const response = await apiRequest(
+      "GET",
+      "/repos/code/search",
+      { ...this.auth, params }
+    );
+    if (!response.ok) {
+      throw new GrepError("Code search returned ok=false");
+    }
+    const matches = [];
+    const caseSensitive = options.caseSensitive ?? false;
+    const flags = caseSensitive ? "g" : "gi";
+    let regex = null;
+    try {
+      regex = new RegExp(options.pattern, flags);
+    } catch {
+    }
+    for (const item of response.data) {
+      for (const line of item.lines) {
+        const plainContent = line.content.replace(/<[^>]*>/g, "");
+        const submatches = [];
+        if (regex) {
+          regex.lastIndex = 0;
+          let m;
+          while ((m = regex.exec(plainContent)) !== null) {
+            submatches.push({
+              match: m[0],
+              startOffset: m.index,
+              endOffset: m.index + m[0].length
+            });
+            if (!regex.global) break;
+          }
+        }
+        matches.push({
+          path: item.filename,
+          lineNumber: line.num,
+          lineContent: plainContent,
+          submatches
+        });
+      }
+    }
+    return { matches, total: response.total };
+  }
+  // ── getFileContents (batch) ───────────────────────────────────────────────
+  async getFileContents(paths, options) {
+    if (paths.length === 0) return [];
+    const ref = await this.resolveRef(options?.ref);
+    const encodedBody = JSON.stringify({ files: paths });
+    const raw = await apiRequest(
+      "GET",
+      `/repos/${this.owner}/${this.name}/file-contents`,
+      {
+        ...this.auth,
+        params: { ref, body: encodedBody }
+      }
+    );
+    return raw.map((item) => {
+      if (!item) return null;
+      return {
+        name: item.name,
+        path: item.path,
+        sha: item.sha,
+        size: item.size,
+        encoding: item.encoding,
+        content: item.content ? item.encoding === "base64" ? Buffer.from(item.content, "base64").toString("utf-8") : item.content : null,
+        downloadUrl: item.download_url
+      };
+    });
+  }
+  // ── glob ──────────────────────────────────────────────────────────────────
+  async glob(options) {
+    const ref = await this.resolveRef(options.ref);
+    const encodedRef = encodeURIComponent(ref);
+    const params = new URLSearchParams();
+    for (const p of options.patterns) {
+      params.append("pattern", p);
+    }
+    if (options.prefix) params.set("prefix", options.prefix);
+    if (options.sizes === false) params.set("sizes", "false");
+    if (options.limit) params.set("limit", String(options.limit));
+    const url = `/repos/${this.owner}/${this.name}/git/trees/${encodedRef}/glob?${params.toString()}`;
+    const data = await apiRequest("GET", url, this.auth);
+    return {
+      entries: data.tree,
+      truncated: data.truncated
+    };
+  }
+  // ── listBranches ──────────────────────────────────────────────────────────
+  async listBranches(options) {
+    const params = {};
+    if (options?.page) params.page = String(options.page);
+    if (options?.limit) params.limit = String(options.limit);
+    const raw = await apiRequest(
+      "GET",
+      `/repos/${this.owner}/${this.name}/branches`,
+      { ...this.auth, params }
+    );
+    return raw.map((b) => ({
+      name: b.name,
+      commit: {
+        id: b.commit?.id ?? "",
+        message: b.commit?.message ?? "",
+        url: b.commit?.url ?? "",
+        timestamp: b.commit?.timestamp ?? "",
+        author: {
+          name: b.commit?.author?.name ?? "",
+          email: b.commit?.author?.email ?? ""
+        }
+      },
+      protected: b.protected ?? false
+    }));
+  }
+  // ── listCommits ──────────────────────────────────────────────────────────
+  async listCommits(options) {
+    const params = {
+      stat: "false",
+      verification: "false",
+      files: "false"
+    };
+    if (options?.sha) params.sha = options.sha;
+    if (options?.path) params.path = options.path;
+    if (options?.since) params.since = options.since;
+    if (options?.until) params.until = options.until;
+    if (options?.page) params.page = String(options.page);
+    if (options?.limit) params.limit = String(options.limit);
+    const raw = await apiRequest(
+      "GET",
+      `/repos/${this.owner}/${this.name}/commits`,
+      { ...this.auth, params }
+    );
+    return raw.map((c) => ({
+      sha: c.sha ?? "",
+      message: c.commit?.message ?? "",
+      author: {
+        name: c.commit?.author?.name ?? "",
+        email: c.commit?.author?.email ?? "",
+        date: c.commit?.author?.date ?? ""
+      },
+      committer: {
+        name: c.commit?.committer?.name ?? "",
+        email: c.commit?.committer?.email ?? "",
+        date: c.commit?.committer?.date ?? ""
+      },
+      html_url: c.html_url ?? "",
+      parents: (c.parents ?? []).map((p) => ({
+        sha: p.sha ?? "",
+        url: p.url ?? ""
+      }))
+    }));
+  }
+  // ── listDir ───────────────────────────────────────────────────────────────
+  async listDir(options) {
+    const ref = await this.resolveRef(options?.ref);
+    const { entries: treeEntries, truncated } = await this.fetchTree(ref);
+    const prefix = options?.path?.replace(/\/$/, "") ?? "";
+    const filtered = treeEntries.filter((e) => {
+      if (prefix && !e.path.startsWith(prefix)) return false;
+      if (!options?.recursive) {
+        const relative = prefix ? e.path.slice(prefix.length).replace(/^\//, "") : e.path;
+        if (relative.includes("/")) return false;
+      }
+      return true;
+    });
+    const entries = filtered.map((e) => ({
+      path: e.path,
+      type: e.type === "blob" ? "file" : "dir",
+      size: e.size,
+      mode: e.mode
+    }));
+    return { entries, truncated };
+  }
+};
+var DEFAULT_HOST = "gitmorph.com";
+function configPath() {
+  const dir = process.env.GM_CONFIG_DIR || join(process.env.HOME || "", ".config", "gm");
+  return join(dir, "config.json");
+}
+function loadConfig() {
+  try {
+    const raw = readFileSync(configPath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function resolveAuth(options) {
+  const token = options?.token || process.env.GM_TOKEN || loadConfig()?.token || null;
+  if (!token) {
+    throw new AuthenticationError();
+  }
+  const host = options?.host || process.env.GM_HOST || loadConfig()?.host || DEFAULT_HOST;
+  return { token, host };
+}
+
+// src/mirror.ts
+var SERVICE_MAP = {
+  github: "github",
+  gitea: "gitea",
+  gitlab: "gitlab"
+};
+function parseSource(source, options) {
+  let cloneAddr;
+  let service;
+  let owner;
+  let repoName;
+  if (source.startsWith("https://") || source.startsWith("http://")) {
+    const url = new URL(source);
+    const pathParts = url.pathname.replace(/^\//, "").replace(/\.git$/, "").split("/");
+    if (pathParts.length < 2 || !pathParts[0] || !pathParts[1]) {
+      throw new MirrorError(`Cannot parse source URL: "${source}". Expected "https://host/owner/repo".`);
+    }
+    owner = pathParts[0];
+    repoName = pathParts[1];
+    cloneAddr = `${url.origin}/${owner}/${repoName}.git`;
+    const hostname = url.hostname;
+    if (hostname.includes("github")) service = SERVICE_MAP.github;
+    else if (hostname.includes("gitlab")) service = SERVICE_MAP.gitlab;
+    else if (hostname.includes("gitea")) service = SERVICE_MAP.gitea;
+    else service = SERVICE_MAP[options?.source ?? "github"];
+  } else {
+    const parts = source.replace(/\.git$/, "").split("/");
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+      throw new MirrorError(`Invalid source: "${source}". Expected "owner/repo" or a full URL.`);
+    }
+    owner = parts[0];
+    repoName = parts[1];
+    const serviceKey = options?.source ?? "github";
+    service = SERVICE_MAP[serviceKey];
+    const hostMap = {
+      github: "https://github.com",
+      gitlab: "https://gitlab.com",
+      gitea: "https://gitea.com"
+    };
+    cloneAddr = `${hostMap[serviceKey]}/${owner}/${repoName}.git`;
+  }
+  return {
+    cloneAddr,
+    service,
+    repoName: options?.repoName ?? repoName,
+    owner
+  };
+}
+async function mirrorRepository(source, auth, options) {
+  const { cloneAddr, service, repoName } = parseSource(source, options);
+  const body = {
+    clone_addr: cloneAddr,
+    repo_name: repoName,
+    service,
+    mirror: true,
+    private: options?.private ?? false,
+    wiki: options?.wiki ?? false,
+    issues: options?.issues ?? false,
+    pull_requests: options?.pullRequests ?? false,
+    releases: options?.releases ?? false,
+    labels: options?.labels ?? false,
+    milestones: options?.milestones ?? false,
+    lfs: options?.lfs ?? false
+  };
+  try {
+    return await apiRequest("POST", "/repos/migrate", {
+      ...auth,
+      body
+    });
+  } catch (err) {
+    if (err instanceof Error && "status" in err) throw err;
+    throw new MirrorError(err.message);
+  }
+}
+
+// src/utils.ts
+function parseRepoSlug(input) {
+  const cleaned = input.replace(/\.git$/, "");
+  const parts = cleaned.split("/");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new GitMorphError(
+      `Invalid repo format: "${input}". Expected "owner/repo".`
+    );
+  }
+  return { owner: parts[0], name: parts[1] };
+}
+
+// src/client.ts
+var GitMorph = class {
+  token;
+  host;
+  constructor(options) {
+    const auth = resolveAuth(options);
+    this.token = auth.token;
+    this.host = auth.host;
+  }
+  get auth() {
+    return { token: this.token, host: this.host };
+  }
+  repo(slug) {
+    const { owner, name } = parseRepoSlug(slug);
+    return new GitMorphRepo(owner, name, this.auth);
+  }
+  async getRepositoryInfo(slug) {
+    const { owner, name } = parseRepoSlug(slug);
+    return apiRequest("GET", `/repos/${owner}/${name}`, this.auth);
+  }
+  async mirror(source, options) {
+    const repository = await mirrorRepository(source, this.auth, options);
+    const repo = this.repo(repository.full_name);
+    return { repository, repo };
+  }
+  async grepAll(options) {
+    const params = {
+      q: options.pattern
+    };
+    if (options.language) params.l = options.language;
+    if (options.page) params.page = String(options.page);
+    if (options.limit) params.limit = String(Math.min(options.limit, 50));
+    if (options.sortByStars) params.sort_by_stars = "true";
+    const response = await apiRequest(
+      "GET",
+      "/repos/code/search",
+      { ...this.auth, params }
+    );
+    const matches = response.data.map((item) => ({
+      repoId: item.repo_id,
+      repoName: item.repo_name,
+      filename: item.filename,
+      commitId: item.commit_id,
+      language: item.language,
+      lines: item.lines.map((l) => ({ num: l.num, content: l.content }))
+    }));
+    return { matches, total: response.total };
+  }
+};
+
+export { ApiError, AuthenticationError, GitMorph, GitMorphError, GitMorphRepo, GrepError, MirrorError };
+//# sourceMappingURL=chunk-QT3Y4ZIS.js.map
+//# sourceMappingURL=chunk-QT3Y4ZIS.js.map