import { execute } from '@ampcode/sdk'

// Simple execution - get the final result
for await (const message of execute({ prompt: 'What files are in this directory?' })) {
    if (message.type === 'result' && !message.is_error) {
        console.log('Result:', message.result)
        break
    }
}

for await (const message of execute({ prompt: 'Run tests' })) {
    if (message.type === 'system') {
        // Session info, available tools, MCP servers
        console.log('Available tools:', message.tools)
    } else if (message.type === 'assistant') {
        // AI responses and tool usage
        console.log('Assistant is working...')
    } else if (message.type === 'result') {
        // Final result (success or error)
        console.log('Done:', message.result)
    }
}

async function getResult(prompt: string): Promise<string> {
    for await (const message of execute({ prompt, options: { dangerouslyAllowAll: true } })) {
        if (message.type === 'result') {
            if (message.is_error) {
                throw new Error(message.error)
            }
            return message.result
        }
    }
    throw new Error('No result received')
}

// Usage
try {
    const result = await getResult('List all TypeScript files in this project')
    console.log('Found files:', result)
} catch (error) {
    console.error('Failed:', error.message)
}

// Continue the most recent conversation
for await (const message of execute({
    prompt: 'What was the last error you found?',
    options: { continue: true },
})) {
    if (message.type === 'result') {
        console.log(message.result)
    }
}

// Continue a specific thread by ID
for await (const message of execute({
    prompt: 'Can you update that code we discussed?',
    options: { continue: 'T-abc123-def456' },
})) {
    if (message.type === 'result') {
        console.log(message.result)
    }
}

for await (const message of execute({
    prompt: 'Refactor the auth module',
    options: { cwd: './my-project' },
})) {
    // Process messages...
}

for await (const message of execute({
    prompt: 'Analyze this project',
    options: {
        logLevel: 'debug', // Shows CLI command in console
        logFile: './amp-debug.log', // Optional: write logs to file
    },
})) {
    // Process messages
}

for await (const message of execute({
    prompt: 'Quickly fix this typo',
    options: {
        mode: 'rush', // Use rush mode for faster responses
    },
})) {
    // Process messages
}

for await (const message of execute({
    prompt: 'Think carefully and explain your plan before coding.',
    options: {
        mode: 'smart',
        effort: 'high',
    },
})) {
    if (message.type === 'result') {
        console.log(message.result)
        break
    }
}

for await (const message of execute({
    prompt: 'Summarize this repo',
    options: {
        labels: ['sdk', 'summary'],
    },
})) {
    if (message.type === 'result') {
        console.log(message.result)
        break
    }
}

for await (const message of execute({
    prompt: 'Analyze this private codebase',
    options: {
        visibility: 'private', // Only you can see this thread
    },
})) {
    if (message.type === 'result') {
        console.log(message.result)
        break
    }
}

import { execute, createPermission } from '@ampcode/sdk'

for await (const message of execute({
    prompt: 'List files and run tests',
    options: {
        permissions: [
            // Allow listing files
            createPermission('Bash', 'allow', { matches: { cmd: 'ls *' } }),
            // Allow running tests
            createPermission('Bash', 'allow', { matches: { cmd: 'npm test' } }),
            // Ask before reading sensitive files
            createPermission('Read', 'ask', { matches: { path: '/etc/*' } }),
        ],
    },
})) {
    // Process messages
}

async function executeWithProgress(prompt: string) {
    console.log('Starting task...')

    for await (const message of execute({ prompt })) {
        if (message.type === 'system' && message.subtype === 'init') {
            console.log('Tools available:', message.tools.join(', '))
        } else if (message.type === 'assistant') {
            // Show tool usage or assistant responses
            const content = message.message.content[0]
            if (content.type === 'tool_use') {
                console.log(`Using ${content.name}...`)
            } else if (content.type === 'text') {
                console.log('Assistant:', content.text.slice(0, 100) + '...')
            }
        } else if (message.type === 'result') {
            if (message.is_error) {
                console.log('Failed:', message.error)
            } else {
                console.log('Completed successfully!')
                console.log(message.result)
            }
        }
    }
}

async function executeWithTimeout(prompt: string, timeoutMs = 30000) {
    const signal = AbortSignal.timeout(timeoutMs)

    try {
        for await (const message of execute({
            prompt,
            signal,
            options: { dangerouslyAllowAll: true },
        })) {
            if (message.type === 'result') {
                return message.result
            }
        }
    } catch (error) {
        if (error.message.includes('aborted')) {
            throw new Error(`Operation timed out after ${timeoutMs}ms`)
        }
        throw error
    }
}

import { execute, type MCPConfig } from '@ampcode/sdk'

const mcpConfig: MCPConfig = {
    playwright: {
        command: 'npx',
        args: ['-y', '@playwright/mcp@latest', '--headless'],
        env: { NODE_ENV: 'production' },
    },
    database: {
        command: 'node',
        args: ['./custom-mcp-server.js'],
        env: { DB_CONNECTION_STRING: process.env.DATABASE_URL },
    },
}

for await (const message of execute({
    prompt: 'Test the login flow on staging environment',
    options: { mcpConfig, dangerouslyAllowAll: true },
})) {
    if (message.type === 'system') {
        console.log(
            'MCP Servers:',
            message.mcp_servers.map((s) => `${s.name}: ${s.status}`),
        )
    }
    // Handle other messages...
}

import { execute, createUserMessage } from '@ampcode/sdk'

async function* generateMessages() {
    yield createUserMessage('Start analyzing the codebase')

    // Wait for some condition or user input
    await new Promise((resolve) => setTimeout(resolve, 1000))

    yield createUserMessage('Now focus on the authentication module')
}

for await (const message of execute({
    prompt: generateMessages(),
})) {
    if (message.type === 'result') {
        console.log(message.result)
    }
}

import { execute } from '@ampcode/sdk'

// Use a custom settings file
for await (const message of execute({
    prompt: 'Deploy the application',
    options: {
        settingsFile: './settings.json',
        logLevel: 'debug',
    },
})) {
    // Handle messages...
}

for await (const message of execute({
    prompt: 'Use my custom deployment scripts',
    options: {
        toolbox: '/usr/repository-path/toolbox', // Path to toolbox scripts
    },
})) {
    // Handle messages...
}

for await (const message of execute({
    prompt: 'Use my custom deployment skill',
    options: {
        skills: './my-skills', // Path to custom skills directory
    },
})) {
    // Process messages
}

function execute(options: ExecuteOptions): AsyncIterable<StreamMessage>

import { execute } from '@ampcode/sdk'

for await (const message of execute({
    prompt: 'Analyze this codebase',
    options: {
        cwd: './my-project',
        dangerouslyAllowAll: true,
    },
})) {
    if (message.type === 'assistant') {
        console.log('Assistant:', message.message.content)
    } else if (message.type === 'result') {
        console.log('Final result:', message.result)
        break
    }
}

function createUserMessage(text: string): UserInputMessage

import { createUserMessage } from '@ampcode/sdk'

const message = createUserMessage('Analyze this code')
console.log(message)
// Output: { type: 'user', message: { role: 'user', content: [{ type: 'text', text: 'Analyze this code' }] } }

function createPermission(
    tool: string,
    action: 'allow' | 'reject' | 'ask' | 'delegate',
    options?: {
        matches?: Record<string, PermissionMatchCondition>
        context?: 'thread' | 'subagent'
        to?: string
    },
): Permission

import { createPermission } from '@ampcode/sdk'

// Allow all Bash commands
createPermission('Bash', 'allow')

// Allow specific git commands
createPermission('Bash', 'allow', {
    matches: { cmd: 'git *' },
})

// Ask before allowing Read operations on sensitive paths
createPermission('Read', 'ask', {
    matches: { path: '/etc/*' },
})

// Delegate web browsing to a custom command
createPermission('mcp__playwright__*', 'delegate', {
    to: 'node browse.js',
})

// Only apply in subagent context
createPermission('Bash', 'reject', {
    context: 'subagent',
})

async function threads.new(options?: ThreadsNewOptions): Promise<string>

import { threads } from '@ampcode/sdk'

// Create a new private thread
const threadId = await threads.new({ visibility: 'private' })
console.log('Created thread:', threadId)

async function threads.markdown(options: ThreadsMarkdownOptions): Promise<string>

import { threads } from '@ampcode/sdk'

// Get thread content as markdown
const markdown = await threads.markdown({ threadId: 'T-abc123-def456' })
console.log(markdown)

interface ExecuteOptions {
    prompt: string | AsyncIterable<UserInputMessage>
    options?: AmpOptions
    signal?: AbortSignal
}

interface AmpOptions {
    cwd?: string
    mode?: 'deep' | 'smart' | 'rush' | 'large'
    effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max'
    dangerouslyAllowAll?: boolean
    noArchiveAfterExecute?: boolean
    visibility?: 'private' | 'unlisted' | 'workspace' | 'group'
    settingsFile?: string
    logLevel?: 'debug' | 'info' | 'warn' | 'error' | 'audit'
    logFile?: string
    mcpConfig?: string | MCPConfig
    env?: Record<string, string>
    continue?: boolean | string
    toolbox?: string
    skills?: string
    enabledTools?: string[]
    permissions?: Permission[]
    labels?: string[]
    thinking?: boolean
}

interface SystemMessage {
    type: 'system'
    subtype: 'init'
    session_id: string
    cwd: string
    tools: string[]
    mcp_servers: Array<{
        name: string
        status: 'connected' | 'connecting' | 'connection-failed' | 'disabled'
    }>
}

interface AssistantMessage {
    type: 'assistant'
    session_id: string
    message: {
        id: string
        type: 'message'
        role: 'assistant'
        model: string
        content: Array<TextContent | ToolUseContent>
        stop_reason: 'end_turn' | 'tool_use' | 'max_tokens' | null
        stop_sequence: string | null
        usage?: Usage
    }
    parent_tool_use_id: string | null
}

interface UserMessage {
    type: 'user'
    session_id: string
    message: {
        role: 'user'
        content: Array<TextContent | ToolResultContent>
    }
    parent_tool_use_id: string | null
}

interface ResultMessage {
    type: 'result'
    subtype: 'success'
    session_id: string
    is_error: false
    result: string
    duration_ms: number
    num_turns: number
    usage?: Usage
    permission_denials?: string[]
}

interface ErrorResultMessage {
    type: 'result'
    subtype: 'error_during_execution' | 'error_max_turns'
    session_id: string
    is_error: true
    error: string
    duration_ms: number
    num_turns: number
    usage?: Usage
    permission_denials?: string[]
}

interface TextContent {
    type: 'text'
    text: string
}

interface ToolUseContent {
    type: 'tool_use'
    id: string
    name: string
    input: Record<string, unknown>
}

interface ToolResultContent {
    type: 'tool_result'
    tool_use_id: string
    content: string
    is_error: boolean
}

interface Usage {
    input_tokens: number
    cache_creation_input_tokens?: number
    cache_read_input_tokens?: number
    output_tokens: number
    service_tier?: string
}

interface UserInputMessage {
    type: 'user'
    message: {
        role: 'user'
        content: Array<{
            type: 'text'
            text: string
        }>
    }
}

type MCPConfig = Record<string, MCPServer>

// MCPServer is a union of stdio and HTTP server configurations

const mcpConfig: MCPConfig = {
    playwright: { command: 'npx', args: ['-y', '@playwright/mcp'] },
    remote: { url: 'https://api.example.com/mcp' },
}

interface ThreadsNewOptions {
    visibility?: 'private' | 'unlisted' | 'workspace' | 'group'
}

interface ThreadsMarkdownOptions {
    threadId: string
}

interface Permission {
    tool: string
    matches?: Record<string, PermissionMatchCondition>
    action: 'allow' | 'reject' | 'ask' | 'delegate'
    context?: 'thread' | 'subagent'
    to?: string
}

import { execute, createPermission } from '@ampcode/sdk'

for await (const message of execute({
    prompt: 'Deploy the application',
    options: {
        permissions: [
            // Allow git commands
            createPermission('Bash', 'allow', { matches: { cmd: 'git *' } }),
            // Allow reading files
            createPermission('Read', 'allow'),
        ],
    },
})) {
    // Handle messages
}

type PermissionMatchCondition =
    | string
    | PermissionMatchCondition[]
    | { [key: string]: PermissionMatchCondition }
    | boolean
    | number
    | null
    | undefined

// String pattern with wildcard
{
    cmd: 'npm *'
}

// Array for OR logic
{
    cmd: ['npm install', 'npm test', 'npm run build']
}

// Regex pattern
{
    cmd: '/^git (status|log|diff)$/'
}

// Nested object matching
{
    env: {
        NODE_ENV: 'production'
    }
}