Go SDK

go get github.com/kairos-connect/kairos-go

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/kairos-connect/kairos-go"
)

func main() {
    // Initialize the client
    client := kairos.NewClient("your_api_key")

    // Create a context
    ctx := context.Background()

    // List tasks
    result, err := client.Tasks.List(ctx, &kairos.TaskListParams{
        Status: kairos.TaskStatusInProgress,
        Limit:  10,
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Found %d tasks\n", result.Pagination.Total)
    for _, task := range result.Data {
        fmt.Printf("- %s (%s)\n", task.Title, task.Status)
    }
}

package main

import (
    "net/http"
    "time"

    "github.com/kairos-connect/kairos-go"
)

func main() {
    // Basic configuration
    client := kairos.NewClient("your_api_key")

    // With options
    client := kairos.NewClient(
        "your_api_key",
        kairos.WithBaseURL("https://gateway.thekairos.app/v1"),
        kairos.WithTimeout(30*time.Second),
        kairos.WithHTTPClient(&http.Client{
            Timeout: 60 * time.Second,
        }),
        kairos.WithRetry(3, time.Second),
    )

    // From environment variable
    // Reads KAIROS_API_KEY
    client := kairos.NewClientFromEnv()
}

import (
    "context"
    "time"
)

// With timeout
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()

task, err := client.Tasks.Get(ctx, "task-id")
if err != nil {
    if ctx.Err() == context.DeadlineExceeded {
        log.Println("Request timed out")
    }
    return
}

// With cancellation
ctx, cancel := context.WithCancel(context.Background())

go func() {
    // Cancel after some condition
    time.Sleep(5 * time.Second)
    cancel()
}()

result, err := client.Tasks.List(ctx, nil)

ctx := context.Background()

// List tasks with filters
result, err := client.Tasks.List(ctx, &kairos.TaskListParams{
    Status:     kairos.TaskStatusInProgress,
    Priority:   kairos.TaskPriorityHigh,
    AssignedTo: "user-id",
    GoalID:     "goal-id",
    Page:       1,
    Limit:      50,
    SortBy:     "due_date",
    SortOrder:  kairos.SortOrderAsc,
})

// Get a single task
task, err := client.Tasks.Get(ctx, "task-id")
fmt.Println(task.Title, task.Status)

// Create a task
newTask, err := client.Tasks.Create(ctx, &kairos.TaskCreateParams{
    Title:       "Implement new feature",
    Description: "Add user authentication",
    GoalID:      "goal-id",
    Priority:    kairos.TaskPriorityHigh,
    DueDate:     time.Now().Add(7 * 24 * time.Hour),
    StoryPoints: 5,
})

// Update a task
updatedTask, err := client.Tasks.Update(ctx, "task-id", &kairos.TaskUpdateParams{
    Status:      kairos.TaskStatusCompleted,
    ActualHours: 6,
})

// Delete a task
err := client.Tasks.Delete(ctx, "task-id")

ctx := context.Background()

// List goals
result, err := client.Goals.List(ctx, &kairos.GoalListParams{
    Status:       kairos.GoalStatusInProgress,
    IncludeTasks: true,
})

// Get a goal with tasks
goal, err := client.Goals.Get(ctx, "goal-id", &kairos.GoalGetParams{
    IncludeTasks:    true,
    IncludeComments: true,
})

fmt.Printf("Goal: %s\n", goal.Title)
fmt.Printf("Progress: %d%%\n", goal.Progress)

for _, task := range goal.Tasks {
    fmt.Printf("  - %s\n", task.Title)
}

ctx := context.Background()

// Get team info
team, err := client.Team.Get(ctx)
fmt.Printf("Team: %s\n", team.Name)

// List team members (teamID required)
members, err := client.Team.ListMembers(ctx, team.ID, nil)

for _, member := range members {
    fmt.Printf("%s (%s)\n", member.Name, member.Role)
}

ctx := context.Background()

// List documents
result, err := client.Documents.List(ctx, &kairos.DocumentListParams{
    DocType:    kairos.DocTypePage,
    Visibility: kairos.VisibilityTeam,
})

// Get document with content
doc, err := client.Documents.Get(ctx, "doc-id", &kairos.DocumentGetParams{
    IncludeContent:  true,
    IncludeChildren: true,
})

fmt.Println(doc.Title)
fmt.Println(doc.PlainText)

import (
    "errors"
    "time"

    "github.com/kairos-connect/kairos-go"
)

task, err := client.Tasks.Get(ctx, "invalid-id")
if err != nil {
    var apiErr *kairos.Error
    if errors.As(err, &apiErr) {
        switch apiErr.Code {
        case kairos.ErrNotFound:
            fmt.Println("Task not found")
        case kairos.ErrValidation:
            fmt.Printf("Validation error: %s\n", apiErr.Message)
        case kairos.ErrRateLimit:
            fmt.Printf("Rate limited. Retry after: %d seconds\n", apiErr.RetryAfter)
            time.Sleep(time.Duration(apiErr.RetryAfter) * time.Second)
        case kairos.ErrUnauthorized:
            fmt.Println("Authentication failed")
        default:
            fmt.Printf("API error: %s - %s\n", apiErr.Code, apiErr.Message)
        }
    } else {
        // Network or other error
        fmt.Printf("Error: %v\n", err)
    }
}

import "github.com/kairos-connect/kairos-go"

// Task type
type Task struct {
    ID          string          `json:"id"`
    TeamID      string          `json:"team_id"`
    GoalID      *string         `json:"goal_id"`
    Title       string          `json:"title"`
    Description *string         `json:"description"`
    Type        TaskType        `json:"type"`
    Status      TaskStatus      `json:"status"`
    Priority    TaskPriority    `json:"priority"`
    AssignedTo  *string         `json:"assigned_to"`
    DueDate     *time.Time      `json:"due_date"`
    StoryPoints *int            `json:"story_points"`
    CreatedAt   time.Time       `json:"created_at"`
    UpdatedAt   time.Time       `json:"updated_at"`
}

// Enums
type TaskStatus string

const (
    TaskStatusToDo       TaskStatus = "to_do"
    TaskStatusInProgress TaskStatus = "in_progress"
    TaskStatusInReview   TaskStatus = "in_review"
    TaskStatusOnHold     TaskStatus = "on_hold"
    TaskStatusBlocked    TaskStatus = "blocked"
    TaskStatusCompleted  TaskStatus = "completed"
)