AI Integration

# Linux
curl -fsSL https://ollama.com/install.sh | sh

# macOS
brew install ollama

# Or download from https://ollama.com

ollama pull qwen2.5-coder    # Default model, good for code generation
ollama pull codellama         # Alternative code model
ollama pull llama3.2          # General purpose

# Auto-detected (Ollama is tried first)
immygo new myapp --ai "a todo list with add and delete"

# Explicit provider and model
immygo new myapp --ai "a calculator" --provider ollama --model codellama

export IMMYGO_OLLAMA_HOST=http://myserver:11434

export ANTHROPIC_API_KEY=sk-ant-...

# Auto-detected when ANTHROPIC_API_KEY is set and Ollama isn't running
immygo new myapp --ai "a dashboard with charts"

# Explicit
immygo new myapp --ai "a chat app" --provider anthropic

# Choose a specific model
immygo new myapp --ai "a settings page" --provider anthropic --model claude-sonnet-4-20250514

# Set the MCP server command
export IMMYGO_MCP_COMMAND="npx @some/mcp-server"

# Optionally specify which tool to call (default: immygo_generate_code)
export IMMYGO_MCP_TOOL="my_code_gen_tool"

# Use it
immygo new myapp --ai "a form builder"

immygo new myapp --ai "a form" --provider mcp --mcp-command "my-mcp-server" --mcp-tool "generate"

import "github.com/amken3d/immygo/ai"

// Use Ollama
provider := ai.NewOllamaProvider("http://localhost:11434", "qwen2.5-coder")

// Use Anthropic
provider := ai.NewAnthropicProvider(os.Getenv("ANTHROPIC_API_KEY"), "claude-sonnet-4-20250514")

// Use MCP
provider := ai.NewMCPClientProvider("my-mcp-server", "generate_code")

// Create an engine with a specific provider
cfg := ai.DefaultConfig()
cfg.SystemPrompt = "You are a helpful coding assistant."
engine := ai.NewEngineWithProvider(cfg, provider)
assistant := ai.NewAssistant("My Assistant", engine)

// Or let ImmyGo auto-detect
ai.SetDefaultProviderConfig(ai.ProviderConfig{
    Provider: "ollama",
    Model:    "codellama",
})
assistant := ai.DefaultAssistant()

import "github.com/amken3d/immygo/ai"

// Create engine and assistant
engine := ai.NewEngine(ai.DefaultConfig())
assistant := ai.NewAssistant("My Assistant", engine)
chatPanel := ai.NewChatPanel(assistant)

// In your layout:
func myLayout(gtx layout.Context, th *theme.Theme) layout.Dimensions {
    return chatPanel.Layout(gtx, th)
}

// Ollama (local)
provider := ai.NewOllamaProvider("", "qwen2.5-coder") // "" = default localhost

engine := ai.NewEngineWithProvider(ai.Config{
    ContextSize:  4096,
    MaxTokens:    1024,
    Temperature:  0.7,
    SystemPrompt: "You are a helpful assistant.",
}, provider)

engine := ai.NewEngine(ai.DefaultConfig())
engine.Load() // resolves provider automatically

assistant := ai.NewAssistant("Helper", engine)

// Load in background, get notified when ready
assistant.LoadAsync(func(err error) {
    fmt.Println("Model loaded and ready!")
})

// Check status:
if assistant.IsLoading() { /* show spinner */ }
if assistant.IsReady()   { /* enable chat */ }

// Default configuration
cfg := ai.DefaultConfig()
// Returns: Config{ContextSize: 2048, MaxTokens: 256, Temperature: 0.7}

// Custom configuration with provider
cfg := ai.Config{
    ContextSize:  4096,
    MaxTokens:    1024,
    Temperature:  0.5,
    SystemPrompt: "You are a coding assistant.",
    ProviderConfig: ai.ProviderConfig{
        Provider: "ollama",
        Model:    "codellama",
    },
}

engine := ai.NewEngine(cfg)
engine.Load()

// Single completion
response, err := engine.Complete(ctx, "What is the capital of France?")
// response = "The capital of France is Paris."

// Streaming completion (token by token)
stream := engine.CompleteStream(ctx, "Explain quantum computing")
for token := range stream {
    if token.Error != nil {
        log.Fatal(token.Error)
    }
    if token.Done {
        break
    }
    fmt.Print(token.Text) // Print each token as it arrives
}

// Conversation history
history := engine.History()       // []Message
engine.ClearHistory()             // Reset conversation

// Check which provider is active
fmt.Println(engine.ProviderName()) // e.g. "ollama (qwen2.5-coder)"

assistant := ai.NewAssistant("CodeHelper", engine)

response, err := assistant.Chat(ctx, "How do I read a file in Go?")
// response = "To read a file in Go, you can use os.ReadFile()..."

stream := assistant.ChatStream(ctx, "Explain goroutines")
for token := range stream {
    if token.Done {
        break
    }
    fmt.Print(token.Text)
}

suggestion, err := assistant.Suggest(ctx, "func calculateTax(amount float64) ")
// suggestion = "float64 {\n\treturn amount * 0.2\n}"

summary, err := assistant.Summarize(ctx, longArticleText)
// summary = "The article discusses three main approaches to..."

assistant.ClearHistory()  // Reset conversation

chatPanel := ai.NewChatPanel(assistant)

// Layout it like any other widget:
chatPanel.Layout(gtx, th)

// Read the message history
for _, msg := range chatPanel.Messages {
    fmt.Printf("[%s] %s\n", msg.Role, msg.Content)
}

// Programmatically add messages
chatPanel.Messages = append(chatPanel.Messages, ai.Message{
    Role:    ai.RoleAssistant,
    Content: "Welcome! How can I help you?",
})

type Message struct {
    Role    Role    // RoleSystem, RoleUser, or RoleAssistant
    Content string
}

type Role string

const (
    RoleSystem    Role = "system"
    RoleUser      Role = "user"
    RoleAssistant Role = "assistant"
)

var searchField = widget.NewSearchField()

func onSearch() {
    query := searchField.Text()
    response, _ := assistant.Chat(ctx, "Search for: "+query)
    // Display response...
}

func validateForm() {
    email := emailField.Text()
    prompt := fmt.Sprintf("Is '%s' a valid email address? Reply YES or NO only.", email)
    response, _ := assistant.Chat(ctx, prompt)
    // Use response for validation feedback
}

func showHelp(widgetName string) {
    prompt := fmt.Sprintf("Briefly explain the '%s' widget in ImmyGo.", widgetName)
    response, _ := assistant.Chat(ctx, prompt)
    // Display in a tooltip or help panel
}

immygo mcp

{
  "mcpServers": {
    "immygo": {
      "command": "go",
      "args": ["run", "./cmd/immygo", "mcp"]
    }
  }
}

echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"capabilities":{}}}' | immygo mcp
echo '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | immygo mcp

# Default template (no AI needed)
immygo new myapp

# AI-generated from description (auto-detects provider)
immygo new myapp --ai "a calculator with basic arithmetic operations"
immygo new myapp --ai "a todo list with add, delete, and mark complete"
immygo new myapp --ai "a dashboard with sidebar navigation and charts"

# With a specific provider
immygo new myapp --ai "a file browser" --provider ollama --model codellama
immygo new myapp --ai "a chat app" --provider anthropic

immygo dev --ai ./myapp/

# With a specific provider
immygo dev --ai --provider ollama --model qwen2.5-coder ./myapp/

ui.Run("Prototype", func() ui.View {
    return ui.Prototype("a login form with email, password, and remember me checkbox")
})

proto := ui.Prototype("a settings panel with toggles")

// Later, when you want to keep the generated code:
proto.Eject() // prints Go source to stdout

# Enable via environment variable
IMMYGO_DEBUG=1 go run ./myapp/

# Also enable AI analysis of the layout tree
IMMYGO_DEBUG=1 IMMYGO_DEBUG_AI=1 go run ./myapp/

ui.EnableDebug()

{
  "type": "VStack",
  "maxW": 1024, "maxH": 768,
  "resultW": 1024, "resultH": 200,
  "children": [
    {"type": "Text", "maxW": 1024, "resultW": 120, "resultH": 24},
    {"type": "Button", "maxW": 1024, "resultW": 100, "resultH": 40}
  ]
}

// Get the full ui package API reference
catalog := ai.WidgetCatalog()

// Get the system prompt for code generation (includes catalog + rules)
system := ai.ImmyGoSystemPrompt()

// Wrap a description for code generation
prompt := ai.CodeGenPrompt("a todo list app")

// Wrap for full app scaffolding
prompt := ai.ScaffoldPrompt("myapp", "a calculator")

// Get a pre-configured singleton assistant
assistant := ai.DefaultAssistant()

// One-call convenience function
code, err := ai.GenerateCode(ctx, "a counter app with reset button")