@morphllm/morphsdk 0.2.21 → 0.2.23

package/dist/git/client.d.ts

@@ -1,255 +0,0 @@
-import { MorphGitConfig, CloneOptions, PushOptions, PullOptions, AddOptions, CommitOptions, StatusOptions, LogOptions, CommitObject, CheckoutOptions, BranchOptions, StatusResult, CommitMetadata } from './types.js';
-import 'isomorphic-git';
-import 'isomorphic-git/http/node';
-import '../tools/utils/resilience.js';
-
-/**
- * Morph Git Client - Simple, high-level Git operations
- * Built on isomorphic-git with explicit configuration
- */
-
-/**
- * MorphGit - Git operations for AI agents with Morph backend
- *
- * @example
- * ```typescript
- * import { MorphGit } from 'morphsdk/git';
- *
- * const morphGit = new MorphGit({
- *   apiKey: process.env.MORPH_API_KEY!,
- *   proxyUrl: 'https://repos.morphllm.com' // Optional
- * });
- *
- * await morphGit.init({ repoId: 'my-project', dir: './my-project' });
- * await morphGit.push({ dir: './my-project' });
- * ```
- */
-declare class MorphGit {
-    private readonly apiKey;
-    private readonly proxyUrl;
-    constructor(config: MorphGitConfig);
-    /**
-     * Get auth callback for isomorphic-git operations
-     * @private
-     */
-    private getAuthCallback;
-    /**
-     * Initialize a new repository
-     * Creates the repo in the database and in the git provider
-     *
-     * @example
-     * ```ts
-     * await morphGit.init({
-     *   repoId: 'my-project',
-     *   dir: './my-project',
-     *   defaultBranch: 'main'
-     * });
-     * ```
-     */
-    init(options: {
-        repoId: string;
-        dir: string;
-        defaultBranch?: string;
-    }): Promise<void>;
-    /**
-     * Clone a repository from Morph repos
-     *
-     * @example
-     * ```ts
-     * await morphGit.clone({
-     *   repoId: 'my-project',
-     *   dir: './my-project'
-     * });
-     * ```
-     */
-    clone(options: CloneOptions): Promise<void>;
-    /**
-     * Push changes to remote repository
-     *
-     * @example
-     * ```ts
-     * await morphGit.push({ dir: './my-project' });
-     * ```
-     */
-    push(options: PushOptions): Promise<void>;
-    /**
-     * Pull changes from remote repository
-     *
-     * @example
-     * ```ts
-     * await morphGit.pull({ dir: './my-project' });
-     * ```
-     */
-    pull(options: PullOptions): Promise<void>;
-    /**
-     * Stage a file for commit
-     *
-     * @example
-     * ```ts
-     * await morphGit.add({
-     *   dir: './my-project',
-     *   filepath: 'src/app.ts'
-     * });
-     * ```
-     */
-    add(options: AddOptions): Promise<void>;
-    /**
-     * Remove a file from staging
-     *
-     * @example
-     * ```ts
-     * await morphGit.remove({
-     *   dir: './my-project',
-     *   filepath: 'src/old-file.ts'
-     * });
-     * ```
-     */
-    remove(options: AddOptions): Promise<void>;
-    /**
-     * Commit staged changes
-     *
-     * @example
-     * ```ts
-     * await morphGit.commit({
-     *   dir: './my-project',
-     *   message: 'Add new feature',
-     *   author: {
-     *     name: 'AI Agent',
-     *     email: 'ai@example.com'
-     *   },
-     *   chatHistory: [
-     *     { role: 'user', content: 'Please add a new feature' },
-     *     { role: 'assistant', content: 'I will add that feature' }
-     *   ],
-     *   recordingId: 'rec_123'
-     * });
-     * ```
-     */
-    commit(options: CommitOptions): Promise<string>;
-    /**
-     * Get status of a file
-     *
-     * @example
-     * ```ts
-     * const status = await morphGit.status({
-     *   dir: './my-project',
-     *   filepath: 'src/app.ts'
-     * });
-     * console.log(status); // 'modified', '*added', etc.
-     * ```
-     */
-    status(options: StatusOptions): Promise<string>;
-    /**
-     * Get commit history
-     *
-     * @example
-     * ```ts
-     * const commits = await morphGit.log({
-     *   dir: './my-project',
-     *   depth: 10
-     * });
-     * ```
-     */
-    log(options: LogOptions): Promise<CommitObject[]>;
-    /**
-     * Checkout a branch or commit
-     *
-     * @example
-     * ```ts
-     * await morphGit.checkout({
-     *   dir: './my-project',
-     *   ref: 'feature-branch'
-     * });
-     * ```
-     */
-    checkout(options: CheckoutOptions): Promise<void>;
-    /**
-     * Create a new branch
-     *
-     * @example
-     * ```ts
-     * await morphGit.branch({
-     *   dir: './my-project',
-     *   name: 'feature-branch',
-     *   checkout: true
-     * });
-     * ```
-     */
-    branch(options: BranchOptions): Promise<void>;
-    /**
-     * List all branches
-     *
-     * @example
-     * ```ts
-     * const branches = await morphGit.listBranches({
-     *   dir: './my-project'
-     * });
-     * ```
-     */
-    listBranches(options: {
-        dir: string;
-    }): Promise<string[]>;
-    /**
-     * Get the current branch name
-     *
-     * @example
-     * ```ts
-     * const branch = await morphGit.currentBranch({
-     *   dir: './my-project'
-     * });
-     * ```
-     */
-    currentBranch(options: {
-        dir: string;
-    }): Promise<string | undefined>;
-    /**
-     * Get list of changed files (similar to git diff --name-only)
-     *
-     * @example
-     * ```ts
-     * const changes = await morphGit.statusMatrix({
-     *   dir: './my-project'
-     * });
-     * ```
-     */
-    statusMatrix(options: {
-        dir: string;
-    }): Promise<StatusResult[]>;
-    /**
-     * Get the current commit hash
-     *
-     * @example
-     * ```ts
-     * const hash = await morphGit.resolveRef({
-     *   dir: './my-project',
-     *   ref: 'HEAD'
-     * });
-     * ```
-     */
-    resolveRef(options: {
-        dir: string;
-        ref: string;
-    }): Promise<string>;
-    /**
-     * Get metadata (chat history, recording ID) attached to a commit
-     *
-     * @example
-     * ```ts
-     * const metadata = await morphGit.getCommitMetadata({
-     *   dir: './my-project',
-     *   commitSha: 'abc123...'
-     * });
-     *
-     * if (metadata) {
-     *   console.log('Chat history:', metadata.chatHistory);
-     *   console.log('Recording ID:', metadata.recordingId);
-     * }
-     * ```
-     */
-    getCommitMetadata(options: {
-        dir: string;
-        commitSha: string;
-    }): Promise<CommitMetadata | null>;
-}
-
-export { MorphGit };

package/dist/git/config.d.ts

@@ -1,11 +0,0 @@
-/**
- * Configuration constants for Morph Git SDK
- */
-/** Default proxy URL for Morph git operations */
-declare const DEFAULT_PROXY_URL = "https://repos.morphllm.com";
-/**
- * Validate API key format
- */
-declare function validateApiKey(apiKey: string): void;
-
-export { DEFAULT_PROXY_URL, validateApiKey };

package/dist/git/index.d.ts

@@ -1,5 +0,0 @@
-export { MorphGit } from './client.js';
-export { AddOptions, BranchOptions, ChatMessage, CheckoutOptions, CloneOptions, CommitMetadata, CommitObject, CommitOptions, DiffOptions, LogOptions, MorphGitConfig, PullOptions, PushOptions, StatusOptions, StatusResult } from './types.js';
-export { default as git } from 'isomorphic-git';
-export { default as http } from 'isomorphic-git/http/node';
-import '../tools/utils/resilience.js';

package/dist/git/types.d.ts

@@ -1,102 +0,0 @@
-import { RetryConfig } from '../tools/utils/resilience.js';
-
-/**
- * Types for Morph Git SDK
- */
-
-interface MorphGitConfig {
-    apiKey?: string;
-    proxyUrl?: string;
-    /** Retry configuration for API calls */
-    retryConfig?: RetryConfig;
-}
-interface CloneOptions {
-    repoId: string;
-    dir: string;
-    branch?: string;
-    depth?: number;
-    singleBranch?: boolean;
-}
-interface PushOptions {
-    dir: string;
-    remote?: string;
-    branch?: string;
-}
-interface PullOptions {
-    dir: string;
-    remote?: string;
-    branch?: string;
-}
-interface AddOptions {
-    dir: string;
-    filepath: string;
-}
-interface ChatMessage {
-    role: string;
-    content: string;
-    [key: string]: any;
-}
-interface CommitMetadata {
-    chatHistory?: ChatMessage[];
-    recordingId?: string;
-}
-interface CommitOptions {
-    dir: string;
-    message: string;
-    author?: {
-        name: string | "Morph AI Agent";
-        email: string | "ai@morphllm.com";
-    };
-    chatHistory?: ChatMessage[];
-    recordingId?: string;
-}
-interface StatusOptions {
-    dir: string;
-    filepath?: string;
-}
-interface LogOptions {
-    dir: string;
-    depth?: number;
-    ref?: string;
-}
-interface CheckoutOptions {
-    dir: string;
-    ref: string;
-}
-interface BranchOptions {
-    dir: string;
-    name: string;
-    checkout?: boolean;
-}
-interface DiffOptions {
-    dir: string;
-    ref1?: string;
-    ref2?: string;
-    filepath?: string;
-}
-interface GitUser {
-    name: string;
-    email: string;
-}
-interface CommitObject {
-    oid: string;
-    commit: {
-        message: string;
-        author: {
-            name: string | "Morph AI Agent";
-            email: string | "ai@morphllm.com";
-            timestamp: number;
-        };
-        committer: {
-            name: string | "Morph AI Agent";
-            email: string | "ai@morphllm.com";
-            timestamp: number;
-        };
-    };
-}
-interface StatusResult {
-    filepath: string;
-    status: 'unmodified' | 'modified' | '*modified' | 'added' | '*added' | 'deleted' | '*deleted' | 'absent';
-}
-
-export type { AddOptions, BranchOptions, ChatMessage, CheckoutOptions, CloneOptions, CommitMetadata, CommitObject, CommitOptions, DiffOptions, GitUser, LogOptions, MorphGitConfig, PullOptions, PushOptions, StatusOptions, StatusResult };

package/dist/index.d.ts

@@ -1,14 +0,0 @@
-export { MorphClient, MorphClientConfig } from './client.js';
-export { FastApplyClient } from './tools/fastapply/core.js';
-export { CodebaseSearchClient } from './tools/codebase_search/core.js';
-export { BrowserClient } from './tools/browser/core.js';
-export { MorphGit } from './git/client.js';
-export { MorphGitConfig } from './git/types.js';
-export { AnthropicRouter, GeminiRouter, OpenAIRouter } from './modelrouter/core.js';
-export { EditFileConfig, EditFileInput, EditFileResult } from './tools/fastapply/types.js';
-export { CodebaseSearchConfig, CodebaseSearchInput, CodebaseSearchResult } from './tools/codebase_search/types.js';
-export { BrowserConfig, BrowserError, BrowserTaskInput, BrowserTaskInputWithSchema, BrowserTaskResult, BrowserTaskWithPromise, BrowserTaskWithPromiseAndSchema, ErrorsResponse, RecordingStatus } from './tools/browser/types.js';
-export { ComplexityLevel, Provider, RouterConfig, RouterInput, RouterMode, RouterResult } from './modelrouter/types.js';
-export { RetryConfig } from './tools/utils/resilience.js';
-import 'isomorphic-git';
-import 'isomorphic-git/http/node';

package/dist/modelrouter/core.d.ts

@@ -1,56 +0,0 @@
-import { RouterConfig, Provider, RouterInput, RouterResult } from './types.js';
-
-/**
- * Core implementation for intelligent model routing
- */
-
-declare abstract class BaseRouter {
-    protected config: Required<Omit<RouterConfig, 'apiKey' | 'retryConfig'>> & Pick<RouterConfig, 'apiKey' | 'retryConfig'>;
-    protected provider: Provider;
-    constructor(provider: Provider, config?: RouterConfig);
-    /**
-     * Select the optimal model for a given input and mode
-     */
-    selectModel(input: RouterInput): Promise<RouterResult>;
-}
-/**
- * OpenAI model router for GPT-5 series
- */
-declare class OpenAIRouter extends BaseRouter {
-    constructor(config?: RouterConfig);
-    /**
-     * Select optimal GPT-5 model
-     *
-     * @param input - User input and mode
-     * @returns Selected model name (gpt-5-mini | gpt-5-low | gpt-5-medium | gpt-5-high)
-     */
-    selectModel(input: RouterInput): Promise<RouterResult>;
-}
-/**
- * Anthropic model router for Claude 4.5 series
- */
-declare class AnthropicRouter extends BaseRouter {
-    constructor(config?: RouterConfig);
-    /**
-     * Select optimal Claude model
-     *
-     * @param input - User input and mode
-     * @returns Selected model name (claude-4.5-haiku | claude-4.5-sonnet)
-     */
-    selectModel(input: RouterInput): Promise<RouterResult>;
-}
-/**
- * Google Gemini model router
- */
-declare class GeminiRouter extends BaseRouter {
-    constructor(config?: RouterConfig);
-    /**
-     * Select optimal Gemini model
-     *
-     * @param input - User input and mode
-     * @returns Selected model name (gemini-2.5-flash | gemini-2.5-pro)
-     */
-    selectModel(input: RouterInput): Promise<RouterResult>;
-}
-
-export { AnthropicRouter, GeminiRouter, OpenAIRouter };

package/dist/modelrouter/index.d.ts

@@ -1,2 +0,0 @@
-export { AnthropicRouter, GeminiRouter, OpenAIRouter } from './core.js';
-export { ComplexityLevel, Provider, RouterConfig, RouterInput, RouterMode, RouterResult } from './types.js';

package/dist/modelrouter/types.d.ts

@@ -1,35 +0,0 @@
-/**
- * Model router types for intelligent model selection
- */
-type ComplexityLevel = 'easy' | 'medium' | 'hard' | 'needs-info';
-type RouterMode = 'balanced' | 'aggressive';
-type Provider = 'openai' | 'anthropic' | 'gemini';
-interface RouterConfig {
-    /** Morph API key (defaults to MORPH_API_KEY env var) */
-    apiKey?: string;
-    /** Router API URL (defaults to https://api.morphllm.com) */
-    apiUrl?: string;
-    /** Request timeout in milliseconds (default: 10000) */
-    timeout?: number;
-    /** Enable debug logging */
-    debug?: boolean;
-    /** Retry configuration */
-    retryConfig?: {
-        maxRetries?: number;
-        initialDelay?: number;
-        maxDelay?: number;
-        backoffMultiplier?: number;
-    };
-}
-interface RouterInput {
-    /** User input or task description */
-    input: string;
-    /** Routing mode: balanced (cheaper models) or aggressive (more capable models) */
-    mode?: RouterMode;
-}
-interface RouterResult {
-    /** Selected model name */
-    model: string;
-}
-
-export type { ComplexityLevel, Provider, RouterConfig, RouterInput, RouterMode, RouterResult };

package/dist/openai-BkKsS30n.d.ts

@@ -1,111 +0,0 @@
-import { ChatCompletionTool } from 'openai/resources/chat/completions';
-import { EditFileInput, EditFileConfig, EditFileResult } from './tools/fastapply/types.js';
-
-/**
- * OpenAI SDK adapter for edit_file tool
- */
-
-/**
- * OpenAI-native tool definition for edit_file
- *
- * @example
- * ```ts
- * import OpenAI from 'openai';
- * import { editFileTool } from 'morphsdk/tools/openai';
- *
- * const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
- *
- * const response = await client.chat.completions.create({
- *   model: "gpt-4o",
- *   tools: [editFileTool],
- *   messages: [{ role: "user", content: "Fix the bug in app.ts" }]
- * });
- * ```
- */
-declare const editFileTool: ChatCompletionTool;
-/**
- * Execute an edit_file tool call
- *
- * @param input - The tool input from GPT (parsed from tool_calls)
- * @param config - Optional configuration
- * @returns The result of the edit operation
- *
- * @example
- * ```ts
- * const args = JSON.parse(toolCall.function.arguments);
- * const result = await execute(args);
- * console.log('Changes applied:', result.udiff);
- * ```
- */
-declare function execute(input: EditFileInput, config?: EditFileConfig): Promise<EditFileResult>;
-/**
- * Get the system prompt for edit_file usage
- *
- * Add this to your system message to guide GPT on using edit_file properly.
- *
- * @example
- * ```ts
- * const response = await client.chat.completions.create({
- *   model: "gpt-4o",
- *   messages: [
- *     { role: "system", content: getSystemPrompt() },
- *     { role: "user", content: "Fix bugs" }
- *   ],
- *   tools: [editFileTool]
- * });
- * ```
- */
-declare function getSystemPrompt(): string;
-/**
- * Format the result for passing back to GPT
- *
- * @param result - The edit result
- * @returns Formatted string for tool message
- */
-declare function formatResult(result: EditFileResult): string;
-/**
- * Create a custom edit_file tool with configuration and methods
- *
- * @param config - Configuration options
- * @returns Tool definition with execute and formatResult methods
- *
- * @example
- * ```ts
- * import OpenAI from 'openai';
- * import { createEditFileTool } from 'morphsdk/tools/fastapply/openai';
- *
- * const tool = createEditFileTool({
- *   baseDir: './src',
- *   generateUdiff: true,
- *   description: 'Custom tool description for your use case'
- * });
- *
- * const client = new OpenAI();
- *
- * const response = await client.chat.completions.create({
- *   model: 'gpt-4o',
- *   tools: [tool], // tool itself is the ChatCompletionTool
- *   messages: [{ role: 'user', content: 'Fix bug in app.ts' }]
- * });
- *
- * // Execute and format
- * const result = await tool.execute(toolCallArgs);
- * const formatted = tool.formatResult(result);
- * ```
- */
-declare function createEditFileTool(config?: EditFileConfig): ChatCompletionTool & {
-    execute: (input: EditFileInput | string) => Promise<EditFileResult>;
-    formatResult: (result: EditFileResult) => string;
-    getSystemPrompt: () => string;
-};
-
-declare const openai_createEditFileTool: typeof createEditFileTool;
-declare const openai_editFileTool: typeof editFileTool;
-declare const openai_execute: typeof execute;
-declare const openai_formatResult: typeof formatResult;
-declare const openai_getSystemPrompt: typeof getSystemPrompt;
-declare namespace openai {
-  export { openai_createEditFileTool as createEditFileTool, editFileTool as default, openai_editFileTool as editFileTool, openai_execute as execute, openai_formatResult as formatResult, openai_getSystemPrompt as getSystemPrompt };
-}
-
-export { execute as a, createEditFileTool as c, editFileTool as e, formatResult as f, getSystemPrompt as g, openai as o };

package/dist/tools/browser/anthropic.d.ts

@@ -1,51 +0,0 @@
-import { Tool } from '@anthropic-ai/sdk/resources/messages.mjs';
-import { BrowserConfig, BrowserTaskInput, BrowserTaskResult } from './types.js';
-import '../utils/resilience.js';
-
-/**
- * Anthropic SDK adapter for browser automation tool
- */
-
-/**
- * Anthropic tool definition for browser automation
- */
-declare const browserTool: Tool;
-/**
- * Create a configured browser tool with execute and formatResult methods
- *
- * @param config - Browser worker configuration
- * @returns Tool definition with execute and formatResult methods
- *
- * @example
- * ```typescript
- * import Anthropic from '@anthropic-ai/sdk';
- * import { createBrowserTool } from 'morphsdk/tools/browser/anthropic';
- *
- * const tool = createBrowserTool({
- *   apiKey: process.env.MORPH_API_KEY,
- *   timeout: 180000
- * });
- *
- * const client = new Anthropic();
- *
- * const response = await client.messages.create({
- *   model: 'claude-sonnet-4-5-20250929',
- *   tools: [tool], // tool itself is the Tool definition
- *   messages: [{
- *     role: 'user',
- *     content: 'Test the checkout flow at https://3000-abc.e2b.dev'
- *   }]
- * });
- *
- * // Execute and format
- * const result = await tool.execute(toolUseBlock.input);
- * const formatted = tool.formatResult(result);
- * ```
- */
-declare function createBrowserTool(config?: BrowserConfig): Tool & {
-    execute: (input: BrowserTaskInput) => Promise<BrowserTaskResult>;
-    formatResult: (result: BrowserTaskResult) => string;
-    getSystemPrompt: () => string;
-};
-
-export { browserTool, createBrowserTool };