import { OpenAI } from 'openai';

const client = new OpenAI({
  apiKey: 'your-enterprise-api-key',
  baseURL: 'https://api.morphllm.com/v1'
});

const testOriginalCode = `
const a = 1
const b = 2
function add(a, b) {
  return a + b
}

function subtract(a, b) {
  return a - b
}

const authenticateUser () => {
  return "Authenticated"
}
`;

// Test data - your agent should generate these
const testInstruction = "I will add the real user authentication function and remove the old authentication method";

const testUpdateSnippet = `
  // ... existing code ...
const authenticateUser = (email, password) => {
  const result = await verifyUser(email, password)
  if (result) {
    return "Authenticated"
  } else {
    return "Unauthenticated"
  }
}
`;

async function applyEnterpriseEdit(
  instruction: string, 
  originalCode: string, 
  updateSnippet: string
): Promise<string> {
  const response = await client.chat.completions.create({
    model: "morph-v3-fast",
    messages: [
      {
        role: "user",
        content: `<instruction>${instruction}</instruction>\n<code>${originalCode}</code>\n<update>${updateSnippet}</update>`
      }
    ]
  });
  
  return response.choices[0].message.content || '';
}

// Example usage
async function main() {
  try {
    const finalCode = await applyEnterpriseEdit(
      testInstruction, 
      testOriginalCode, 
      testUpdateSnippet
    );
    console.log("Final merged code:");
    console.log(finalCode);
  } catch (error) {
    console.error("Error applying edit:", error);
  }
}

// Run the example
main();

import openai
import asyncio

client = openai.OpenAI(
    api_key="your-enterprise-api-key",
    base_url="https://api.morphllm.com/v1"
)

test_original_code = """
const a = 1
const b = 2
def add(a, b):
  return a + b
}

def subtract(a, b):
  return a - b
}

def authenticateUser ():
  return "Authenticated"
}
"""

# Test data - your agent should generate these
test_instruction = "I will add the real user authentication function and remove the old authentication method" # This is the instruction that your agent should generate

test_update_snippet = """
def authenticateUser (email, password) => {
  # ... existing code ...
  result = await verifyUser(email, password)
  if (result) {
    return "Authenticated"
  } else {
    return "Unauthenticated"
  }
}
"""

def apply_enterprise_edit(instruction: str, original_code: str, update_snippet: str):
    """Apply an enterprise edit using Morph's instruction-guided editing."""
    response = client.chat.completions.create(
        model="morph-v3-fast",
        messages=[
            {
                "role": "user",
                "content": f"<instruction>{instruction}</instruction>\n<code>{original_code}</code>\n<update>{update_snippet}</update>"
            }
        ]
    )
    
    return response.choices[0].message.content

# Example usage
if __name__ == "__main__":
    final_code = apply_enterprise_edit(
        test_instruction, 
        test_original_code, 
        test_update_snippet
    )
    print("Final merged code:")
    print(final_code)

const finalCode = response.choices[0].message.content;
// Write to file or return to your application
await fs.writeFile(targetFile, finalCode);

final_code = response.choices[0].message.content
# Write to file or return to your application  
with open(target_file, 'w') as f:
    f.write(final_code)