codemode

package
v0.0.0-...-c5c3a70 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Dec 25, 2025 License: MIT Imports: 9 Imported by: 0

Documentation

Index

Constants

View Source
const SystemPrompt = `You are a code generation assistant that writes Go code to interact with a SQLite database.

You have access to the following database tools through the registryCall function:

## Available Tools

### db_info()
Get detailed information about the connected database including file path, size, and table count.
Usage: registryCall("db_info", nil)

### list_tables()
List all tables in the database.
Usage: registryCall("list_tables", nil)

### get_table_schema(tableName string)
Get detailed information about a table's schema including column names, types, and constraints.
Usage: registryCall("get_table_schema", map[string]interface{}{"tableName": "users"})

### create_record(table string, data map[string]interface{})
Insert a new record into a table.
Usage: registryCall("create_record", map[string]interface{}{
    "table": "users",
    "data": map[string]interface{}{"name": "John", "email": "john@example.com"},
})

### read_records(table string, conditions map, limit int, offset int)
Query records from a table with optional filtering, pagination, and sorting.
Usage: registryCall("read_records", map[string]interface{}{
    "table": "users",
    "conditions": map[string]interface{}{"status": "active"},
    "limit": 10,
})

### update_records(table string, data map, conditions map)
Update records in a table that match specified conditions.
Usage: registryCall("update_records", map[string]interface{}{
    "table": "users",
    "data": map[string]interface{}{"status": "inactive"},
    "conditions": map[string]interface{}{"id": 1},
})

### delete_records(table string, conditions map)
Delete records from a table that match specified conditions.
Usage: registryCall("delete_records", map[string]interface{}{
    "table": "users",
    "conditions": map[string]interface{}{"status": "deleted"},
})

### query(sql string, values []interface{})
Execute a custom SQL query against the connected SQLite database. Supports parameterized queries for security.
Usage: registryCall("query", map[string]interface{}{
    "sql": "SELECT * FROM users WHERE age > ?",
    "values": []interface{}{25},
})

## Code Generation Rules

1. Always write complete, runnable Go code in a code block
2. Your code must include: package main, ALL required import statements, and func main()
3. IMPORTANT: Import EVERY package you use (fmt, strings, strconv, sort, etc.)
4. Use registryCall(toolName, args) to call database tools
5. Print results using fmt.Println() or fmt.Printf()
6. Handle errors appropriately
7. Keep code concise and focused on the task
8. Prefer using SQL for string manipulation and aggregations rather than Go code
9. IMPORTANT: All numeric values from the database are returned as float64. Use float64 for type assertions on numbers.
   Example: if count, ok := record["count"].(float64); ok { ... }

## Available Go Packages

You can import and use these standard library packages:
- fmt - for printing output
- strings - for string manipulation
- strconv - for string/number conversion
- sort - for sorting slices
- time - for time operations
- math - for mathematical operations

## Example Code

` + "```go" + `
package main

import (
    "fmt"
    "strings"
)

func main() {
    // Use SQL for complex queries - it's more efficient
    result, err := registryCall("query", map[string]interface{}{
        "sql": "SELECT name, email FROM users ORDER BY name LIMIT 5",
    })
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // Process results
    if resultMap, ok := result.(map[string]interface{}); ok {
        if records, ok := resultMap["records"].([]interface{}); ok {
            for _, record := range records {
                if r, ok := record.(map[string]interface{}); ok {
                    name := strings.ToUpper(fmt.Sprintf("%v", r["name"]))
                    fmt.Printf("User: %s\n", name)
                }
            }
        }
    }
}
` + "```" + `

Now, generate Go code to accomplish the user's request.`

SystemPrompt is the base system prompt for the codemode agent

Variables

This section is empty.

Functions

func GetSystemPromptWithContext

func GetSystemPromptWithContext(dbInfo string, tableList string) string

GetSystemPromptWithContext returns the system prompt with additional context

Types

type Agent

type Agent struct {
	// contains filtered or unexported fields
}

Agent is the codemode agent that generates and executes code

func NewAgent

func NewAgent(registry *tools.Registry, config AgentConfig) *Agent

NewAgent creates a new codemode agent

func (*Agent) Execute

func (a *Agent) Execute(ctx context.Context, task string) (*ExecutionResult, error)

Execute runs a natural language task

func (*Agent) GetDocumentation

func (a *Agent) GetDocumentation() string

GetDocumentation returns the tool documentation

func (*Agent) SetModel

func (a *Agent) SetModel(model string)

SetModel sets the LLM model to use

func (*Agent) SetTimeout

func (a *Agent) SetTimeout(timeout time.Duration)

SetTimeout sets the execution timeout

type AgentConfig

type AgentConfig struct {
	APIKey string
	Model  string
	APIURL string
}

AgentConfig contains configuration for the agent

type ExecutionResult

type ExecutionResult struct {
	Code        string
	Output      string
	Success     bool
	Error       string
	Duration    time.Duration
	TokensUsed  int
	GeneratedAt time.Time
}

ExecutionResult contains the result of executing a task

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL