@morphllm/gitmorph-sdk 0.2.1 → 0.3.0

package/dist/instructions-BE0g1eFs.d.ts

@@ -0,0 +1,284 @@
+import { G as GitMorph, e as GitMorphRepo, F as FileContent, c as FileContentEntry, m as GrepResult, g as GlobResult, s as ListDirResult, B as Branch, C as Commit, j as GrepAllResult, u as Repository } from './client-B_I_0i1T.js';
+import { z } from 'zod';
+
+/**
+ * Execution context passed to every tool's `execute` function.
+ *
+ * `getRepo` resolves a `GitMorphRepo` handle. In pinned mode (set via
+ * `createGitmorphRepoTools`), it ignores its argument and always returns the
+ * pinned repo. In multi-repo mode, it requires the tool's `repo` input field.
+ */
+interface ToolCtx {
+    readonly gm: GitMorph;
+    readonly getRepo: (slugFromInput?: string) => GitMorphRepo;
+}
+declare const GITMORPH_TOOLS: readonly [{
+    readonly name: "gm_read_file";
+    readonly description: string;
+    readonly schema: z.ZodObject<{
+        path: z.ZodString;
+        ref: z.ZodOptional<z.ZodString>;
+        startLine: z.ZodOptional<z.ZodNumber>;
+        endLine: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        ref?: string | undefined;
+        startLine?: number | undefined;
+        endLine?: number | undefined;
+    }, {
+        path: string;
+        ref?: string | undefined;
+        startLine?: number | undefined;
+        endLine?: number | undefined;
+    }>;
+    readonly repoScoped: true;
+    readonly execute: ({ getRepo }: ToolCtx, input: any) => Promise<FileContent>;
+}, {
+    readonly name: "gm_read_files";
+    readonly description: string;
+    readonly schema: z.ZodObject<{
+        paths: z.ZodArray<z.ZodString, "many">;
+        ref: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        paths: string[];
+        ref?: string | undefined;
+    }, {
+        paths: string[];
+        ref?: string | undefined;
+    }>;
+    readonly repoScoped: true;
+    readonly execute: ({ getRepo }: ToolCtx, input: any) => Promise<(FileContentEntry | null)[]>;
+}, {
+    readonly name: "gm_grep";
+    readonly description: string;
+    readonly schema: z.ZodObject<{
+        pattern: z.ZodString;
+        language: z.ZodOptional<z.ZodString>;
+        caseSensitive: z.ZodOptional<z.ZodBoolean>;
+        maxMatches: z.ZodOptional<z.ZodNumber>;
+        page: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        pattern: string;
+        language?: string | undefined;
+        caseSensitive?: boolean | undefined;
+        maxMatches?: number | undefined;
+        page?: number | undefined;
+    }, {
+        pattern: string;
+        language?: string | undefined;
+        caseSensitive?: boolean | undefined;
+        maxMatches?: number | undefined;
+        page?: number | undefined;
+    }>;
+    readonly repoScoped: true;
+    readonly execute: ({ getRepo }: ToolCtx, input: any) => Promise<GrepResult>;
+}, {
+    readonly name: "gm_glob";
+    readonly description: string;
+    readonly schema: z.ZodObject<{
+        patterns: z.ZodArray<z.ZodString, "many">;
+        ref: z.ZodOptional<z.ZodString>;
+        prefix: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        patterns: string[];
+        ref?: string | undefined;
+        prefix?: string | undefined;
+        limit?: number | undefined;
+    }, {
+        patterns: string[];
+        ref?: string | undefined;
+        prefix?: string | undefined;
+        limit?: number | undefined;
+    }>;
+    readonly repoScoped: true;
+    readonly execute: ({ getRepo }: ToolCtx, input: any) => Promise<GlobResult>;
+}, {
+    readonly name: "gm_list_dir";
+    readonly description: string;
+    readonly schema: z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+        ref: z.ZodOptional<z.ZodString>;
+        recursive: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        path?: string | undefined;
+        ref?: string | undefined;
+        recursive?: boolean | undefined;
+    }, {
+        path?: string | undefined;
+        ref?: string | undefined;
+        recursive?: boolean | undefined;
+    }>;
+    readonly repoScoped: true;
+    readonly execute: ({ getRepo }: ToolCtx, input: any) => Promise<ListDirResult>;
+}, {
+    readonly name: "gm_list_branches";
+    readonly description: string;
+    readonly schema: z.ZodObject<{
+        page: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        page?: number | undefined;
+        limit?: number | undefined;
+    }, {
+        page?: number | undefined;
+        limit?: number | undefined;
+    }>;
+    readonly repoScoped: true;
+    readonly execute: ({ getRepo }: ToolCtx, input: any) => Promise<Branch[]>;
+}, {
+    readonly name: "gm_list_commits";
+    readonly description: string;
+    readonly schema: z.ZodObject<{
+        sha: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        since: z.ZodOptional<z.ZodString>;
+        until: z.ZodOptional<z.ZodString>;
+        page: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        path?: string | undefined;
+        page?: number | undefined;
+        limit?: number | undefined;
+        sha?: string | undefined;
+        since?: string | undefined;
+        until?: string | undefined;
+    }, {
+        path?: string | undefined;
+        page?: number | undefined;
+        limit?: number | undefined;
+        sha?: string | undefined;
+        since?: string | undefined;
+        until?: string | undefined;
+    }>;
+    readonly repoScoped: true;
+    readonly execute: ({ getRepo }: ToolCtx, input: any) => Promise<Commit[]>;
+}, {
+    readonly name: "gm_grep_all";
+    readonly description: string;
+    readonly schema: z.ZodObject<{
+        pattern: z.ZodString;
+        language: z.ZodOptional<z.ZodString>;
+        sortByStars: z.ZodOptional<z.ZodBoolean>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        pattern: string;
+        language?: string | undefined;
+        limit?: number | undefined;
+        sortByStars?: boolean | undefined;
+    }, {
+        pattern: string;
+        language?: string | undefined;
+        limit?: number | undefined;
+        sortByStars?: boolean | undefined;
+    }>;
+    readonly repoScoped: false;
+    readonly execute: ({ gm }: ToolCtx, input: any) => Promise<GrepAllResult>;
+}, {
+    readonly name: "gm_get_repo_info";
+    readonly description: string;
+    readonly schema: z.ZodObject<{
+        repo: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        repo: string;
+    }, {
+        repo: string;
+    }>;
+    readonly repoScoped: false;
+    readonly execute: ({ gm }: ToolCtx, input: any) => Promise<Repository>;
+}, {
+    readonly name: "gm_mirror";
+    readonly description: string;
+    readonly schema: z.ZodObject<{
+        source: z.ZodString;
+        repoName: z.ZodOptional<z.ZodString>;
+        private: z.ZodOptional<z.ZodBoolean>;
+        issues: z.ZodOptional<z.ZodBoolean>;
+        pullRequests: z.ZodOptional<z.ZodBoolean>;
+        releases: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        issues?: boolean | undefined;
+        repoName?: string | undefined;
+        private?: boolean | undefined;
+        pullRequests?: boolean | undefined;
+        releases?: boolean | undefined;
+    }, {
+        source: string;
+        issues?: boolean | undefined;
+        repoName?: string | undefined;
+        private?: boolean | undefined;
+        pullRequests?: boolean | undefined;
+        releases?: boolean | undefined;
+    }>;
+    readonly repoScoped: false;
+    readonly execute: ({ gm }: ToolCtx, input: any) => Promise<{
+        full_name: string;
+        default_branch: string;
+        stars_count: number;
+        language: string;
+    }>;
+}];
+/** Union of every built-in tool name. */
+type GitmorphToolName = (typeof GITMORPH_TOOLS)[number]["name"];
+/** Tool names that are included by default (excludes opt-in `gm_mirror`). */
+type DefaultGitmorphToolName = Exclude<GitmorphToolName, "gm_mirror">;
+/** Names of tools included by default — use for filtering. */
+declare const DEFAULT_TOOL_NAMES: readonly ["gm_read_file", "gm_read_files", "gm_grep", "gm_glob", "gm_list_dir", "gm_list_branches", "gm_list_commits", "gm_grep_all", "gm_get_repo_info"];
+
+/**
+ * Options accepted by every adapter's `createGitmorphTools` factory.
+ *
+ * @typeParam Only - Literal tuple of tool names. When passed as a `const`
+ *   array, the return type of the factory narrows to exactly those tools.
+ */
+interface CreateToolsOptions<Only extends readonly GitmorphToolName[] = readonly GitmorphToolName[]> {
+    /**
+     * Restrict to these tool names. Narrows the factory's return type.
+     *
+     * @example
+     * createGitmorphTools(gm, { only: ["gm_grep", "gm_read_file"] as const })
+     */
+    only?: Only;
+    /** Remove these tools. Applied after `only`. */
+    exclude?: readonly GitmorphToolName[];
+    /**
+     * Rename tools. Keys are built-in names; values are the new names.
+     * Names must be unique after renaming.
+     *
+     * @example
+     * createGitmorphTools(gm, { rename: { gm_grep: "search_code" } })
+     */
+    rename?: Partial<Record<GitmorphToolName, string>>;
+    /**
+     * Include `gm_mirror` in the tool set. Off by default because mirroring
+     * triggers a server-side clone — don't let agents fire it speculatively.
+     */
+    includeMirror?: boolean;
+    /**
+     * Maximum serialized bytes per tool result (Anthropic/OpenAI/MCP only).
+     * Larger results are replaced with a truncation notice. Default: 262144 (256 KB).
+     */
+    maxOutputBytes?: number;
+}
+
+/**
+ * Optional system prompt snippet to append to your agent's system message.
+ * Gives the model explicit guidance on when to reach for each GitMorph tool.
+ *
+ * Re-exported from every adapter subpath (`/ai`, `/anthropic`, `/openai`,
+ * `/mcp`) so you can import it alongside the tools.
+ *
+ * @example
+ * import { createGitmorphTools, GITMORPH_SYSTEM_PROMPT } from "@morphllm/gitmorph-sdk/ai";
+ *
+ * const result = await generateText({
+ *   model,
+ *   system: `You are a code reading assistant.\n\n${GITMORPH_SYSTEM_PROMPT}`,
+ *   tools: createGitmorphTools(gm),
+ *   prompt: "Find every useEffect in facebook/react",
+ * });
+ */
+declare const GITMORPH_SYSTEM_PROMPT: string;
+
+export { type CreateToolsOptions as C, DEFAULT_TOOL_NAMES as D, type GitmorphToolName as G, type DefaultGitmorphToolName as a, GITMORPH_SYSTEM_PROMPT as b };

package/dist/mcp/bin.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/mcp/bin.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { GitMorph } from '../chunk-QT3Y4ZIS.js';
+import { startGitmorphMcpServer } from '../chunk-JXXUBMF6.js';
+import '../chunk-FXEX72CO.js';
+import '../chunk-A3AOZFPE.js';
+
+// src/mcp/bin.ts
+async function main() {
+  try {
+    const gm = new GitMorph();
+    await startGitmorphMcpServer(gm);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[gitmorph-mcp] ${message}
+`);
+    process.exit(1);
+  }
+}
+void main();
+//# sourceMappingURL=bin.js.map
+//# sourceMappingURL=bin.js.map

package/dist/mcp/bin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/mcp/bin.ts"],"names":[],"mappings":";;;;;;;AAIA,eAAe,IAAA,GAAO;AACpB,EAAA,IAAI;AACF,IAAA,MAAM,EAAA,GAAK,IAAI,QAAA,EAAS;AACxB,IAAA,MAAM,uBAAuB,EAAE,CAAA;AAAA,EACjC,SAAS,GAAA,EAAK;AACZ,IAAA,MAAM,UAAU,GAAA,YAAe,KAAA,GAAQ,GAAA,CAAI,OAAA,GAAU,OAAO,GAAG,CAAA;AAC/D,IAAA,OAAA,CAAQ,MAAA,CAAO,KAAA,CAAM,CAAA,eAAA,EAAkB,OAAO;AAAA,CAAI,CAAA;AAClD,IAAA,OAAA,CAAQ,KAAK,CAAC,CAAA;AAAA,EAChB;AACF;AAEA,KAAK,IAAA,EAAK","file":"bin.js","sourcesContent":["#!/usr/bin/env node\nimport { GitMorph } from \"../client.js\";\nimport { startGitmorphMcpServer } from \"./index.js\";\n\nasync function main() {\n  try {\n    const gm = new GitMorph();\n    await startGitmorphMcpServer(gm);\n  } catch (err) {\n    const message = err instanceof Error ? err.message : String(err);\n    process.stderr.write(`[gitmorph-mcp] ${message}\\n`);\n    process.exit(1);\n  }\n}\n\nvoid main();\n"]}

package/dist/mcp/index.d.ts

@@ -0,0 +1,29 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { G as GitMorph } from '../client-B_I_0i1T.js';
+import { C as CreateToolsOptions } from '../instructions-BE0g1eFs.js';
+export { D as DEFAULT_TOOL_NAMES, b as GITMORPH_SYSTEM_PROMPT, G as GitmorphToolName } from '../instructions-BE0g1eFs.js';
+import 'zod';
+
+/**
+ * Build an MCP server that exposes the GitMorph toolkit over stdio.
+ *
+ * Use this when you want to register GitMorph with any MCP-compatible client
+ * (Claude Desktop, Cursor, Claude Code, etc.). For the common case, prefer
+ * the shipped CLI: `npx @morphllm/gitmorph-sdk mcp`.
+ *
+ * @example
+ * ```ts
+ * import { GitMorph } from "@morphllm/gitmorph-sdk";
+ * import { startGitmorphMcpServer } from "@morphllm/gitmorph-sdk/mcp";
+ *
+ * await startGitmorphMcpServer(new GitMorph());
+ * ```
+ */
+declare function createGitmorphMcpServer(gm: GitMorph, opts?: CreateToolsOptions): Server;
+/**
+ * Start an MCP stdio server for the GitMorph toolkit. Resolves when the
+ * server's transport disconnects.
+ */
+declare function startGitmorphMcpServer(gm: GitMorph, opts?: CreateToolsOptions): Promise<void>;
+
+export { CreateToolsOptions, createGitmorphMcpServer, startGitmorphMcpServer };

package/dist/mcp/index.js

@@ -0,0 +1,5 @@
+export { createGitmorphMcpServer, startGitmorphMcpServer } from '../chunk-JXXUBMF6.js';
+import '../chunk-FXEX72CO.js';
+export { DEFAULT_TOOL_NAMES, GITMORPH_SYSTEM_PROMPT } from '../chunk-A3AOZFPE.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/mcp/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/openai/index.d.ts

@@ -0,0 +1,60 @@
+import OpenAI from 'openai';
+import { G as GitMorph } from '../client-B_I_0i1T.js';
+import { G as GitmorphToolName, C as CreateToolsOptions } from '../instructions-BE0g1eFs.js';
+export { D as DEFAULT_TOOL_NAMES, a as DefaultGitmorphToolName, b as GITMORPH_SYSTEM_PROMPT } from '../instructions-BE0g1eFs.js';
+import 'zod';
+
+/**
+ * Return value of {@link createGitmorphTools} for OpenAI. `tools` is a drop-in
+ * for `chat.completions.create({ tools })`; `handleToolCall` consumes one
+ * `tool_call` from the assistant message and returns a ready-to-send tool
+ * message.
+ */
+interface GitmorphOpenAITools {
+    readonly tools: OpenAI.Chat.Completions.ChatCompletionTool[];
+    /**
+     * Execute a tool_call and return a `tool` role message. Never throws —
+     * errors are serialized into the message content so the model can recover.
+     */
+    handleToolCall(call: OpenAI.Chat.Completions.ChatCompletionMessageToolCall): Promise<OpenAI.Chat.Completions.ChatCompletionToolMessageParam>;
+}
+/**
+ * Create OpenAI SDK tools + dispatcher for a {@link GitMorph} client.
+ *
+ * @example
+ * ```ts
+ * import OpenAI from "openai";
+ * import { GitMorph } from "@morphllm/gitmorph-sdk";
+ * import { createGitmorphTools, GITMORPH_SYSTEM_PROMPT } from "@morphllm/gitmorph-sdk/openai";
+ *
+ * const openai = new OpenAI();
+ * const gm = new GitMorph();
+ * const { tools, handleToolCall } = createGitmorphTools(gm);
+ *
+ * const messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [
+ *   { role: "system", content: GITMORPH_SYSTEM_PROMPT },
+ *   { role: "user", content: "Find every useEffect in facebook/react" },
+ * ];
+ *
+ * for (let step = 0; step < 10; step++) {
+ *   const res = await openai.chat.completions.create({ model: "gpt-4o", tools, messages });
+ *   const msg = res.choices[0]!.message;
+ *   messages.push(msg);
+ *   if (!msg.tool_calls?.length) break;
+ *   const results = await Promise.all(msg.tool_calls.map(handleToolCall));
+ *   messages.push(...results);
+ * }
+ * ```
+ */
+declare function createGitmorphTools<const Only extends readonly GitmorphToolName[] = readonly GitmorphToolName[]>(gm: GitMorph, opts?: CreateToolsOptions<Only>): GitmorphOpenAITools;
+/**
+ * Pinned variant — every tool operates on a single repository.
+ *
+ * @example
+ * ```ts
+ * const { tools, handleToolCall } = createGitmorphRepoTools(gm, "facebook/react");
+ * ```
+ */
+declare function createGitmorphRepoTools<const Only extends readonly GitmorphToolName[] = readonly GitmorphToolName[]>(gm: GitMorph, slug: string, opts?: CreateToolsOptions<Only>): GitmorphOpenAITools;
+
+export { CreateToolsOptions, type GitmorphOpenAITools, GitmorphToolName, createGitmorphRepoTools, createGitmorphTools };

package/dist/openai/index.js

@@ -0,0 +1,75 @@
+import { toJsonSchema, clampOutput } from '../chunk-FXEX72CO.js';
+import { resolveToolSet } from '../chunk-A3AOZFPE.js';
+export { DEFAULT_TOOL_NAMES, GITMORPH_SYSTEM_PROMPT } from '../chunk-A3AOZFPE.js';
+
+// src/openai/index.ts
+function createGitmorphTools(gm, opts = {}) {
+  return build(resolveToolSet(gm, opts), opts);
+}
+function createGitmorphRepoTools(gm, slug, opts = {}) {
+  return build(resolveToolSet(gm, opts, slug), opts);
+}
+function build(normalized, opts) {
+  const byName = new Map(normalized.map((t) => [t.name, t]));
+  const maxBytes = opts.maxOutputBytes;
+  const tools = normalized.map(
+    (t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: toJsonSchema(t.schema)
+      }
+    })
+  );
+  const handleToolCall = async (call) => {
+    const name = call.function.name;
+    const def = byName.get(name);
+    if (!def) return errorMessage(call.id, `Unknown tool: ${name}`);
+    let args;
+    try {
+      args = call.function.arguments ? JSON.parse(call.function.arguments) : {};
+    } catch (err) {
+      return errorMessage(
+        call.id,
+        `Invalid JSON arguments for ${name}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    const parsed = def.schema.safeParse(args);
+    if (!parsed.success) {
+      return errorMessage(
+        call.id,
+        `Invalid input for ${name}: ${parsed.error.message}`
+      );
+    }
+    try {
+      const result = await def.execute(parsed.data);
+      return {
+        role: "tool",
+        tool_call_id: call.id,
+        content: clampOutput(result, maxBytes)
+      };
+    } catch (err) {
+      return errorMessage(call.id, describeError(err));
+    }
+  };
+  return { tools, handleToolCall };
+}
+function errorMessage(tool_call_id, message) {
+  return {
+    role: "tool",
+    tool_call_id,
+    content: JSON.stringify({ error: message })
+  };
+}
+function describeError(err) {
+  if (err instanceof Error) {
+    const name = err.name && err.name !== "Error" ? `${err.name}: ` : "";
+    return `${name}${err.message}`;
+  }
+  return typeof err === "string" ? err : JSON.stringify(err);
+}
+
+export { createGitmorphRepoTools, createGitmorphTools };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/openai/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/openai/index.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["import type OpenAI from \"openai\";\nimport type { GitMorph } from \"../client.js\";\nimport {\n  resolveToolSet,\n  type CreateToolsOptions,\n  type NormalizedTool,\n} from \"../tools/core.js\";\nimport { toJsonSchema } from \"../tools/json-schema.js\";\nimport { clampOutput } from \"../tools/truncate.js\";\nimport type { GitmorphToolName } from \"../tools/registry.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, DefaultGitmorphToolName } from \"../tools/registry.js\";\n\n/**\n * Return value of {@link createGitmorphTools} for OpenAI. `tools` is a drop-in\n * for `chat.completions.create({ tools })`; `handleToolCall` consumes one\n * `tool_call` from the assistant message and returns a ready-to-send tool\n * message.\n */\nexport interface GitmorphOpenAITools {\n  readonly tools: OpenAI.Chat.Completions.ChatCompletionTool[];\n  /**\n   * Execute a tool_call and return a `tool` role message. Never throws —\n   * errors are serialized into the message content so the model can recover.\n   */\n  handleToolCall(\n    call: OpenAI.Chat.Completions.ChatCompletionMessageToolCall,\n  ): Promise<OpenAI.Chat.Completions.ChatCompletionToolMessageParam>;\n}\n\n/**\n * Create OpenAI SDK tools + dispatcher for a {@link GitMorph} client.\n *\n * @example\n * ```ts\n * import OpenAI from \"openai\";\n * import { GitMorph } from \"@morphllm/gitmorph-sdk\";\n * import { createGitmorphTools, GITMORPH_SYSTEM_PROMPT } from \"@morphllm/gitmorph-sdk/openai\";\n *\n * const openai = new OpenAI();\n * const gm = new GitMorph();\n * const { tools, handleToolCall } = createGitmorphTools(gm);\n *\n * const messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [\n *   { role: \"system\", content: GITMORPH_SYSTEM_PROMPT },\n *   { role: \"user\", content: \"Find every useEffect in facebook/react\" },\n * ];\n *\n * for (let step = 0; step < 10; step++) {\n *   const res = await openai.chat.completions.create({ model: \"gpt-4o\", tools, messages });\n *   const msg = res.choices[0]!.message;\n *   messages.push(msg);\n *   if (!msg.tool_calls?.length) break;\n *   const results = await Promise.all(msg.tool_calls.map(handleToolCall));\n *   messages.push(...results);\n * }\n * ```\n */\nexport function createGitmorphTools<\n  const Only extends readonly GitmorphToolName[] = readonly GitmorphToolName[],\n>(\n  gm: GitMorph,\n  opts: CreateToolsOptions<Only> = {},\n): GitmorphOpenAITools {\n  return build(resolveToolSet(gm, opts), opts);\n}\n\n/**\n * Pinned variant — every tool operates on a single repository.\n *\n * @example\n * ```ts\n * const { tools, handleToolCall } = createGitmorphRepoTools(gm, \"facebook/react\");\n * ```\n */\nexport function createGitmorphRepoTools<\n  const Only extends readonly GitmorphToolName[] = readonly GitmorphToolName[],\n>(\n  gm: GitMorph,\n  slug: string,\n  opts: CreateToolsOptions<Only> = {},\n): GitmorphOpenAITools {\n  return build(resolveToolSet(gm, opts, slug), opts);\n}\n\n// ── Internals ────────────────────────────────────────────────────────────────\n\nfunction build(\n  normalized: NormalizedTool[],\n  opts: CreateToolsOptions,\n): GitmorphOpenAITools {\n  const byName = new Map(normalized.map((t) => [t.name, t]));\n  const maxBytes = opts.maxOutputBytes;\n\n  const tools: OpenAI.Chat.Completions.ChatCompletionTool[] = normalized.map(\n    (t) => ({\n      type: \"function\",\n      function: {\n        name: t.name,\n        description: t.description,\n        parameters: toJsonSchema(t.schema) as Record<string, unknown>,\n      },\n    }),\n  );\n\n  const handleToolCall: GitmorphOpenAITools[\"handleToolCall\"] = async (call) => {\n    const name = call.function.name;\n    const def = byName.get(name);\n    if (!def) return errorMessage(call.id, `Unknown tool: ${name}`);\n\n    let args: unknown;\n    try {\n      args = call.function.arguments\n        ? JSON.parse(call.function.arguments)\n        : {};\n    } catch (err) {\n      return errorMessage(\n        call.id,\n        `Invalid JSON arguments for ${name}: ${\n          err instanceof Error ? err.message : String(err)\n        }`,\n      );\n    }\n\n    const parsed = def.schema.safeParse(args);\n    if (!parsed.success) {\n      return errorMessage(\n        call.id,\n        `Invalid input for ${name}: ${parsed.error.message}`,\n      );\n    }\n\n    try {\n      const result = await def.execute(parsed.data);\n      return {\n        role: \"tool\",\n        tool_call_id: call.id,\n        content: clampOutput(result, maxBytes),\n      };\n    } catch (err) {\n      return errorMessage(call.id, describeError(err));\n    }\n  };\n\n  return { tools, handleToolCall };\n}\n\nfunction errorMessage(\n  tool_call_id: string,\n  message: string,\n): OpenAI.Chat.Completions.ChatCompletionToolMessageParam {\n  return {\n    role: \"tool\",\n    tool_call_id,\n    content: JSON.stringify({ error: message }),\n  };\n}\n\nfunction describeError(err: unknown): string {\n  if (err instanceof Error) {\n    const name = err.name && err.name !== \"Error\" ? `${err.name}: ` : \"\";\n    return `${name}${err.message}`;\n  }\n  return typeof err === \"string\" ? err : JSON.stringify(err);\n}\n"]}

package/package.json

@@ -1,30 +1,78 @@
 {
   "name": "@morphllm/gitmorph-sdk",
-  "version": "0.2.1",
-  "description": "TypeScript SDK for GitMorph",
+  "version": "0.3.0",
+  "description": "Agent-native TypeScript SDK for reading Git repositories. Drop-in tools for the Vercel AI SDK, Anthropic, OpenAI, and MCP.",
   "type": "module",
+  "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./ai": {
+      "types": "./dist/ai/index.d.ts",
+      "import": "./dist/ai/index.js"
+    },
+    "./anthropic": {
+      "types": "./dist/anthropic/index.d.ts",
+      "import": "./dist/anthropic/index.js"
+    },
+    "./openai": {
+      "types": "./dist/openai/index.d.ts",
+      "import": "./dist/openai/index.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp/index.d.ts",
+      "import": "./dist/mcp/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "gitmorph-mcp": "./dist/mcp/bin.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir dist --target node --format esm && tsc --emitDeclarationOnly --outDir dist",
+    "build": "tsup && chmod +x dist/mcp/bin.js",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.test.json",
     "prepublishOnly": "bun run build"
   },
   "publishConfig": {
     "access": "public"
   },
+  "peerDependencies": {
+    "zod": "^3.23.0",
+    "zod-to-json-schema": "^3.23.0",
+    "ai": "^5.0.0",
+    "@anthropic-ai/sdk": "^0.30.0",
+    "openai": "^4.55.0",
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "zod": { "optional": true },
+    "zod-to-json-schema": { "optional": true },
+    "ai": { "optional": true },
+    "@anthropic-ai/sdk": { "optional": true },
+    "openai": { "optional": true },
+    "@modelcontextprotocol/sdk": { "optional": true }
+  },
   "devDependencies": {
+    "@anthropic-ai/sdk": "^0.30.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "ai": "^5.0.0",
     "bun-types": "latest",
-    "typescript": "^5.0.0"
+    "openai": "^4.55.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.0",
+    "zod": "^3.23.0",
+    "zod-to-json-schema": "^3.23.0"
   },
   "repository": {
     "type": "git",

package/dist/api.d.ts

@@ -1,10 +0,0 @@
-interface RequestOptions {
-    host: string;
-    token: string;
-    body?: unknown;
-    params?: Record<string, string>;
-}
-export declare function apiRequest<T = unknown>(method: string, path: string, options: RequestOptions): Promise<T>;
-export declare function apiRequestRaw(method: string, path: string, options: RequestOptions): Promise<string>;
-export {};
-//# sourceMappingURL=api.d.ts.map

package/dist/api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AAEA,UAAU,cAAc;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAmCD,wBAAsB,UAAU,CAAC,CAAC,GAAG,OAAO,EAC1C,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,CAAC,CAAC,CAcZ;AAED,wBAAsB,aAAa,CACjC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,MAAM,CAAC,CAWjB"}

package/dist/client.d.ts

@@ -1,13 +0,0 @@
-import { GitMorphRepo } from "./repo.js";
-import type { GitMorphOptions, Repository, MirrorOptions, MirrorResult, GrepAllOptions, GrepAllResult } from "./types.js";
-export declare class GitMorph {
-    private token;
-    private host;
-    constructor(options?: GitMorphOptions);
-    private get auth();
-    repo(slug: string): GitMorphRepo;
-    getRepositoryInfo(slug: string): Promise<Repository>;
-    mirror(source: string, options?: MirrorOptions): Promise<MirrorResult>;
-    grepAll(options: GrepAllOptions): Promise<GrepAllResult>;
-}
-//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EACV,eAAe,EACf,UAAU,EACV,aAAa,EACb,YAAY,EACZ,cAAc,EACd,aAAa,EAEd,MAAM,YAAY,CAAC;AAyBpB,qBAAa,QAAQ;IACnB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,IAAI,CAAS;gBAET,OAAO,CAAC,EAAE,eAAe;IAMrC,OAAO,KAAK,IAAI,GAEf;IAED,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY;IAK1B,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAKpD,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAMtE,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CA0B/D"}

package/dist/config.d.ts

@@ -1,8 +0,0 @@
-export declare function resolveAuth(options?: {
-    token?: string;
-    host?: string;
-}): {
-    token: string;
-    host: string;
-};
-//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AA6BA,wBAAgB,WAAW,CAAC,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IACxE,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,CAoBA"}

package/dist/errors.d.ts

@@ -1,18 +0,0 @@
-export declare class GitMorphError extends Error {
-    constructor(message: string);
-}
-export declare class AuthenticationError extends GitMorphError {
-    constructor(message?: string);
-}
-export declare class ApiError extends GitMorphError {
-    status: number;
-    url: string;
-    constructor(message: string, status: number, url: string);
-}
-export declare class MirrorError extends GitMorphError {
-    constructor(message: string);
-}
-export declare class GrepError extends GitMorphError {
-    constructor(message: string);
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,mBAAoB,SAAQ,aAAa;gBACxC,OAAO,CAAC,EAAE,MAAM;CAO7B;AAED,qBAAa,QAAS,SAAQ,aAAa;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;gBAEA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;CAMzD;AAED,qBAAa,WAAY,SAAQ,aAAa;gBAChC,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,SAAU,SAAQ,aAAa;gBAC9B,OAAO,EAAE,MAAM;CAI5B"}