release v1.1.5

.gitignore

@@ -13,4 +13,5 @@ shell-code/build.env
 bin-linux-amd64/*
 bin-linux-arm64/*
 binaries-for-upload/*
-gpt_results
+gpt_results
+shell-code/jwt.admin.token

Dockerfiles/ImageBuild/Dockerfile

@@ -1,8 +1,9 @@
-FROM --platform=${BUILDPLATFORM} golang:1.23-alpine AS builder
+FROM --platform=${BUILDPLATFORM} golang:1.24.6-alpine3.22 AS builder
 
 ARG TARGETARCH
 
-RUN apk add git && go install mvdan.cc/garble@latest
+# RUN apk add git 
+#&& go install mvdan.cc/garble@latest
 
 WORKDIR /app
 
@@ -11,8 +12,8 @@ COPY . .
 RUN echo $BUILDPLATFORM > buildplatform
 RUN echo $TARGETARCH > targetarch
 
-# RUN GOOS=linux GOARCH=$TARGETARCH go build -o /app/go-lcg .
+RUN GOOS=linux GOARCH=$TARGETARCH go build -ldflags="-w -s" -o /app/go-lcg .
-RUN GOOS=${TARGETOS} GOARCH=${TARGETARCH} garble -literals -tiny build -ldflags="-w -s" -o /app/go-lcg .
+#RUN GOOS=${TARGETOS} GOARCH=${TARGETARCH} garble -literals -tiny build -ldflags="-w -s" -o /app/go-lcg .
 
 FROM alpine:latest
 

Dockerfiles/LocalCompile/Dockerfile

@@ -1,15 +1,16 @@
-FROM --platform=${BUILDPLATFORM} golang:1.23-alpine AS build
+FROM --platform=${BUILDPLATFORM} golang:1.24.6-alpine3.22 AS build
 ARG TARGETOS
 ARG TARGETARCH
-RUN apk add git && go install mvdan.cc/garble@latest
+# RUN apk add git 
+#&& go install mvdan.cc/garble@latest
 WORKDIR /src
 ENV CGO_ENABLED=0
 COPY go.* .
 RUN go mod download
 COPY . .
 
-# RUN GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -o /out/go-lcg .
+RUN GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -ldflags="-w -s -buildid=" -trimpath -o /out/go-lcg .
-RUN GOOS=${TARGETOS} GOARCH=${TARGETARCH} garble  -literals -tiny build -ldflags="-w -s" -o /out/go-lcg .
+# RUN GOOS=${TARGETOS} GOARCH=${TARGETARCH} garble  -literals -tiny build -ldflags="-w -s" -o /out/go-lcg .
 
 FROM scratch AS bin-unix
 COPY --from=build /out/go-lcg /lcg

README.md

@@ -1,8 +1,11 @@
-## Linux Command GPT (lcg)
+# Linux Command GPT (lcg)
+
 Get Linux commands in natural language with the power of ChatGPT.
 
-### Installation
+## Installation
+
 Build from source
+
 ```bash
 > git clone --depth 1 https://github.com/asrul10/linux-command-gpt.git ~/.linux-command-gpt
 > cd ~/.linux-command-gpt
@@ -13,7 +16,7 @@ Build from source
 
 Or you can [download lcg executable file](https://github.com/asrul10/linux-command-gpt/releases)
 
-### Example Usage
+## Example Usage
 
 ```bash
 > lcg I want to extract linux-command-gpt.tar.gz file
@@ -39,24 +42,30 @@ for host in "${hosts[@]}"; do
   ssh $host "echo 'Hello, world!' > /tmp/hello.txt"
 done
 ```
+
 This script defines an array `hosts` that contains the names of the hosts to connect to. The loop iterates over each element in the array and uses the `ssh` command to execute a simple command on the remote host. In this case, the command is `echo 'Hello, world!' > /tmp/hello.txt`, which writes the string "Hello, world!" to a file called `/tmp/hello.txt`.
 
 You can modify the script to run any command you like by replacing the `echo` command with your desired command. For example, if you want to run a Python script on each host, you could use the following command:
+
 ```bash
 ssh $host "python /path/to/script.py"
 ```
+
 This will execute the Python script located at `/path/to/script.py` on the remote host.
 
 You can also modify the script to run multiple commands in a single SSH session by using the `&&` operator to chain the commands together. For example:
+
 ```bash
 ssh $host "echo 'Hello, world!' > /tmp/hello.txt && python /path/to/script.py"
 ```
+
 This will execute both the `echo` command and the Python script in a single SSH session.
 
 I hope this helps! Let me know if you have any questions or need further assistance.
 
 Do you want to (c)opy, (r)egenerate, or take (N)o action on the command? (c/r/N):
-```
+
+``` text
 
 To use the "copy to clipboard" feature, you need to install either the `xclip` or `xsel` package.
 
@@ -69,4 +78,25 @@ To use the "copy to clipboard" feature, you need to install either the `xclip` o
 --file        -f  read command from file
 --update-key  -u  update the API key
 --delete-key  -d  delete the API key
+
+# ollama example
+export LCG_PROVIDER=ollama
+export LCG_HOST=http://192.168.87.108:11434/
+export LCG_MODEL=codegeex4
+
+lcg "I want to extract linux-command-gpt.tar.gz file"
+
+export LCG_PROVIDER=proxy
+export LCG_HOST=http://localhost:8080
+export LCG_MODEL=GigaChat-2
+export LCG_JWT_TOKEN=your_jwt_token_here
+
+lcg "I want to extract linux-command-gpt.tar.gz file"
+
+lcg health
+
+lcg config
+
+lcg update-jwt
+
 ```

VERSION.txt

@@ -1 +1 @@
-v1.0.3
+v1.1.5

go.mod

@@ -7,6 +7,6 @@ require github.com/atotto/clipboard v0.1.4
 require (
 	github.com/cpuguy83/go-md2man/v2 v2.0.5 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/urfave/cli/v2 v2.27.5 // indirect
+	github.com/urfave/cli/v2 v2.27.5
 	github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect
 )

gpt/gpt.go

@@ -1,24 +1,40 @@
 package gpt
 
 import (
-	"bytes"
-	"encoding/json"
 	"fmt"
-	"io"
-	"net/http"
 	"os"
 	"path/filepath"
 	"strings"
 )
 
+// ProxySimpleChatRequest структура для простого запроса
+type ProxySimpleChatRequest struct {
+	Message string `json:"message"`
+	Model   string `json:"model,omitempty"`
+}
+
+// ProxySimpleChatResponse структура ответа для простого запроса
+type ProxySimpleChatResponse struct {
+	Response string `json:"response"`
+	Usage    struct {
+		PromptTokens     int `json:"prompt_tokens"`
+		CompletionTokens int `json:"completion_tokens"`
+		TotalTokens      int `json:"total_tokens"`
+	} `json:"usage,omitempty"`
+	Model   string `json:"model,omitempty"`
+	Timeout int    `json:"timeout_seconds,omitempty"`
+}
+
+// Gpt3 обновленная структура с поддержкой разных провайдеров
 type Gpt3 struct {
-	CompletionUrl string
+	Provider     Provider
-	Prompt        string
+	Prompt       string
-	Model         string
+	Model        string
-	HomeDir       string
+	HomeDir      string
-	ApiKeyFile    string
+	ApiKeyFile   string
-	ApiKey        string
+	ApiKey       string
-	Temperature   float64
+	Temperature  float64
+	ProviderType string // "ollama", "proxy"
 }
 
 type Chat struct {
@@ -135,6 +151,11 @@ func (gpt3 *Gpt3) DeleteKey() {
 }
 
 func (gpt3 *Gpt3) InitKey() {
+	// Для ollama и proxy провайдеров не нужен API ключ
+	if gpt3.ProviderType == "ollama" || gpt3.ProviderType == "proxy" {
+		return
+	}
+
 	load := gpt3.loadApiKey()
 	if load {
 		return
@@ -145,55 +166,51 @@ func (gpt3 *Gpt3) InitKey() {
 	gpt3.storeApiKey(apiKey)
 }
 
-func (gpt3 *Gpt3) Completions(ask string) string {
+// NewGpt3 создает новый экземпляр GPT с выбранным провайдером
-	req, err := http.NewRequest("POST", gpt3.CompletionUrl, nil)
+func NewGpt3(providerType, host, apiKey, model, prompt string, temperature float64, timeout int) *Gpt3 {
-	if err != nil {
+	var provider Provider
-		panic(err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-	// req.Header.Set("Authorization", "Bearer "+strings.TrimSpace(gpt3.ApiKey))
 
+	switch providerType {
+	case "proxy":
+		provider = NewProxyAPIProvider(host, apiKey, model, timeout) // apiKey используется как JWT токен
+	case "ollama":
+		provider = NewOllamaProvider(host, model, temperature, timeout)
+	default:
+		provider = NewOllamaProvider(host, model, temperature, timeout)
+	}
+
+	return &Gpt3{
+		Provider:     provider,
+		Prompt:       prompt,
+		Model:        model,
+		ApiKey:       apiKey,
+		Temperature:  temperature,
+		ProviderType: providerType,
+	}
+}
+
+// Completions обновленный метод с поддержкой разных провайдеров
+func (gpt3 *Gpt3) Completions(ask string) string {
 	messages := []Chat{
 		{"system", gpt3.Prompt},
-		{"user", ask + "." + gpt3.Prompt},
+		{"user", ask + ". " + gpt3.Prompt},
-	}
-	payload := Gpt3Request{
-		Model:    gpt3.Model,
-		Messages: messages,
-		Stream:   false,
-		Options:  Gpt3Options{gpt3.Temperature},
 	}
 
-	payloadJson, err := json.Marshal(payload)
+	response, err := gpt3.Provider.Chat(messages)
 	if err != nil {
-		panic(err)
+		fmt.Printf("Ошибка при выполнении запроса: %v\n", err)
-	}
-	req.Body = io.NopCloser(bytes.NewBuffer(payloadJson))
-
-	client := &http.Client{}
-	resp, err := client.Do(req)
-	if err != nil {
-		panic(err)
-	}
-	defer resp.Body.Close()
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		panic(err)
-	}
-
-	if resp.StatusCode != http.StatusOK {
-		fmt.Println(string(body))
 		return ""
 	}
 
-	// var res Gpt3Response
+	return response
-	var res OllamaResponse
+}
-	err = json.Unmarshal(body, &res)
+
-	if err != nil {
+// Health проверяет состояние провайдера
-		panic(err)
+func (gpt3 *Gpt3) Health() error {
-	}
+	return gpt3.Provider.Health()
-
+}
-	// return strings.TrimSpace(res.Choices[0].Message.Content)
+
-	return strings.TrimSpace(res.Message.Content)
+// GetAvailableModels возвращает список доступных моделей
+func (gpt3 *Gpt3) GetAvailableModels() ([]string, error) {
+	return gpt3.Provider.GetAvailableModels()
 }

gpt/prompts.go

@@ -0,0 +1,203 @@
+package gpt
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// SystemPrompt представляет системный промпт
+type SystemPrompt struct {
+	ID          int    `json:"id"`
+	Name        string `json:"name"`
+	Description string `json:"description"`
+	Content     string `json:"content"`
+}
+
+// PromptManager управляет системными промптами
+type PromptManager struct {
+	Prompts    []SystemPrompt
+	ConfigFile string
+	HomeDir    string
+}
+
+// NewPromptManager создает новый менеджер промптов
+func NewPromptManager(homeDir string) *PromptManager {
+	configFile := filepath.Join(homeDir, ".lcg_prompts.json")
+
+	pm := &PromptManager{
+		ConfigFile: configFile,
+		HomeDir:    homeDir,
+	}
+
+	// Загружаем предустановленные промпты
+	pm.loadDefaultPrompts()
+
+	// Загружаем пользовательские промпты
+	pm.loadCustomPrompts()
+
+	return pm
+}
+
+// loadDefaultPrompts загружает предустановленные промпты
+func (pm *PromptManager) loadDefaultPrompts() {
+	defaultPrompts := []SystemPrompt{
+		{
+			ID:          1,
+			Name:        "linux-command",
+			Description: "Generate Linux commands (default)",
+			Content:     "Reply with linux command and nothing else. Output with plain response - no need formatting. No need explanation. No need code blocks. No need ` symbols.",
+		},
+		{
+			ID:          2,
+			Name:        "linux-command-with-explanation",
+			Description: "Generate Linux commands with explanation",
+			Content:     "Generate a Linux command and provide a brief explanation of what it does. Format: COMMAND: explanation",
+		},
+		{
+			ID:          3,
+			Name:        "linux-command-safe",
+			Description: "Generate safe Linux commands",
+			Content:     "Generate a safe Linux command that won't cause data loss or system damage. Reply with linux command and nothing else. Output with plain response - no need formatting.",
+		},
+		{
+			ID:          4,
+			Name:        "linux-command-verbose",
+			Description: "Generate Linux commands with detailed explanation",
+			Content:     "Generate a Linux command and provide detailed explanation including what each flag does and potential alternatives.",
+		},
+		{
+			ID:          5,
+			Name:        "linux-command-simple",
+			Description: "Generate simple Linux commands",
+			Content:     "Generate a simple, easy-to-understand Linux command. Avoid complex flags and options when possible.",
+		},
+	}
+
+	pm.Prompts = defaultPrompts
+}
+
+// loadCustomPrompts загружает пользовательские промпты из файла
+func (pm *PromptManager) loadCustomPrompts() {
+	if _, err := os.Stat(pm.ConfigFile); os.IsNotExist(err) {
+		return
+	}
+
+	data, err := os.ReadFile(pm.ConfigFile)
+	if err != nil {
+		return
+	}
+
+	var customPrompts []SystemPrompt
+	if err := json.Unmarshal(data, &customPrompts); err != nil {
+		return
+	}
+
+	// Добавляем пользовательские промпты с новыми ID
+	for i, prompt := range customPrompts {
+		prompt.ID = len(pm.Prompts) + i + 1
+		pm.Prompts = append(pm.Prompts, prompt)
+	}
+}
+
+// saveCustomPrompts сохраняет пользовательские промпты
+func (pm *PromptManager) saveCustomPrompts() error {
+	// Находим пользовательские промпты (ID > 5)
+	var customPrompts []SystemPrompt
+	for _, prompt := range pm.Prompts {
+		if prompt.ID > 5 {
+			customPrompts = append(customPrompts, prompt)
+		}
+	}
+
+	data, err := json.MarshalIndent(customPrompts, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(pm.ConfigFile, data, 0644)
+}
+
+// GetPromptByID возвращает промпт по ID
+func (pm *PromptManager) GetPromptByID(id int) (*SystemPrompt, error) {
+	for _, prompt := range pm.Prompts {
+		if prompt.ID == id {
+			return &prompt, nil
+		}
+	}
+	return nil, fmt.Errorf("промпт с ID %d не найден", id)
+}
+
+// GetPromptByName возвращает промпт по имени
+func (pm *PromptManager) GetPromptByName(name string) (*SystemPrompt, error) {
+	for _, prompt := range pm.Prompts {
+		if strings.EqualFold(prompt.Name, name) {
+			return &prompt, nil
+		}
+	}
+	return nil, fmt.Errorf("промпт с именем '%s' не найден", name)
+}
+
+// ListPrompts выводит список всех доступных промптов
+func (pm *PromptManager) ListPrompts() {
+	fmt.Println("Available system prompts:")
+	fmt.Println("ID | Name                      | Description")
+	fmt.Println("---+---------------------------+--------------------------------")
+
+	for _, prompt := range pm.Prompts {
+		description := prompt.Description
+		if len(description) > 80 {
+			description = description[:77] + "..."
+		}
+		fmt.Printf("%-2d | %-25s | %s\n",
+			prompt.ID,
+			truncateString(prompt.Name, 25),
+			description)
+	}
+}
+
+// AddCustomPrompt добавляет новый пользовательский промпт
+func (pm *PromptManager) AddCustomPrompt(name, description, content string) error {
+	// Проверяем, что имя уникально
+	for _, prompt := range pm.Prompts {
+		if strings.EqualFold(prompt.Name, name) {
+			return fmt.Errorf("промпт с именем '%s' уже существует", name)
+		}
+	}
+
+	newPrompt := SystemPrompt{
+		ID:          len(pm.Prompts) + 1,
+		Name:        name,
+		Description: description,
+		Content:     content,
+	}
+
+	pm.Prompts = append(pm.Prompts, newPrompt)
+	return pm.saveCustomPrompts()
+}
+
+// DeleteCustomPrompt удаляет пользовательский промпт
+func (pm *PromptManager) DeleteCustomPrompt(id int) error {
+	if id <= 5 {
+		return fmt.Errorf("нельзя удалить предустановленный промпт")
+	}
+
+	for i, prompt := range pm.Prompts {
+		if prompt.ID == id {
+			pm.Prompts = append(pm.Prompts[:i], pm.Prompts[i+1:]...)
+			return pm.saveCustomPrompts()
+		}
+	}
+
+	return fmt.Errorf("промпт с ID %d не найден", id)
+}
+
+// truncateString обрезает строку до указанной длины
+func truncateString(s string, maxLen int) string {
+	if len(s) <= maxLen {
+		return s
+	}
+	return s[:maxLen-3] + "..."
+}

gpt/providers.go

@@ -0,0 +1,296 @@
+package gpt
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// Provider интерфейс для работы с разными LLM провайдерами
+type Provider interface {
+	Chat(messages []Chat) (string, error)
+	Health() error
+	GetAvailableModels() ([]string, error)
+}
+
+// ProxyAPIProvider реализация для прокси API (gin-restapi)
+type ProxyAPIProvider struct {
+	BaseURL    string
+	JWTToken   string
+	Model      string
+	HTTPClient *http.Client
+}
+
+// ProxyChatRequest структура запроса к прокси API
+type ProxyChatRequest struct {
+	Messages       []Chat   `json:"messages"`
+	Model          string   `json:"model,omitempty"`
+	Temperature    float64  `json:"temperature,omitempty"`
+	TopP           float64  `json:"top_p,omitempty"`
+	Stream         bool     `json:"stream,omitempty"`
+	SystemContent  string   `json:"system_content,omitempty"`
+	UserContent    string   `json:"user_content,omitempty"`
+	RandomWords    []string `json:"random_words,omitempty"`
+	FallbackString string   `json:"fallback_string,omitempty"`
+}
+
+// ProxyChatResponse структура ответа от прокси API
+type ProxyChatResponse struct {
+	Response string `json:"response"`
+	Usage    struct {
+		PromptTokens     int `json:"prompt_tokens"`
+		CompletionTokens int `json:"completion_tokens"`
+		TotalTokens      int `json:"total_tokens"`
+	} `json:"usage,omitempty"`
+	Error   string `json:"error,omitempty"`
+	Model   string `json:"model,omitempty"`
+	Timeout int    `json:"timeout_seconds,omitempty"`
+}
+
+// ProxyHealthResponse структура ответа health check
+type ProxyHealthResponse struct {
+	Status  string `json:"status"`
+	Message string `json:"message"`
+	Model   string `json:"default_model,omitempty"`
+	Timeout int    `json:"default_timeout_seconds,omitempty"`
+}
+
+// OllamaProvider реализация для Ollama API
+type OllamaProvider struct {
+	BaseURL     string
+	Model       string
+	Temperature float64
+	HTTPClient  *http.Client
+}
+
+// OllamaTagsResponse структура ответа для получения списка моделей
+type OllamaTagsResponse struct {
+	Models []struct {
+		Name       string `json:"name"`
+		ModifiedAt string `json:"modified_at"`
+		Size       int64  `json:"size"`
+	} `json:"models"`
+}
+
+func NewProxyAPIProvider(baseURL, jwtToken, model string, timeout int) *ProxyAPIProvider {
+	return &ProxyAPIProvider{
+		BaseURL:    strings.TrimSuffix(baseURL, "/"),
+		JWTToken:   jwtToken,
+		Model:      model,
+		HTTPClient: &http.Client{Timeout: time.Duration(timeout) * time.Second},
+	}
+}
+
+func NewOllamaProvider(baseURL, model string, temperature float64, timeout int) *OllamaProvider {
+	return &OllamaProvider{
+		BaseURL:     strings.TrimSuffix(baseURL, "/"),
+		Model:       model,
+		Temperature: temperature,
+		HTTPClient:  &http.Client{Timeout: time.Duration(timeout) * time.Second},
+	}
+}
+
+// Chat для ProxyAPIProvider
+func (p *ProxyAPIProvider) Chat(messages []Chat) (string, error) {
+	// Используем основной endpoint /api/v1/protected/sberchat/chat
+	payload := ProxyChatRequest{
+		Messages:       messages,
+		Model:          p.Model,
+		Temperature:    0.5,
+		TopP:           0.5,
+		Stream:         false,
+		RandomWords:    []string{"linux", "command", "gpt"},
+		FallbackString: "I'm sorry, I can't help with that. Please try again.",
+	}
+
+	jsonData, err := json.Marshal(payload)
+	if err != nil {
+		return "", fmt.Errorf("ошибка маршалинга запроса: %w", err)
+	}
+
+	req, err := http.NewRequest("POST", p.BaseURL+"/api/v1/protected/sberchat/chat", bytes.NewBuffer(jsonData))
+	if err != nil {
+		return "", fmt.Errorf("ошибка создания запроса: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	if p.JWTToken != "" {
+		req.Header.Set("Authorization", "Bearer "+p.JWTToken)
+	}
+
+	resp, err := p.HTTPClient.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("ошибка выполнения запроса: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("ошибка чтения ответа: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("ошибка API: %d - %s", resp.StatusCode, string(body))
+	}
+
+	var response ProxyChatResponse
+	if err := json.Unmarshal(body, &response); err != nil {
+		return "", fmt.Errorf("ошибка парсинга ответа: %w", err)
+	}
+
+	if response.Error != "" {
+		return "", fmt.Errorf("ошибка прокси API: %s", response.Error)
+	}
+
+	if response.Response == "" {
+		return "", fmt.Errorf("пустой ответ от API")
+	}
+
+	return strings.TrimSpace(response.Response), nil
+}
+
+// Health для ProxyAPIProvider
+func (p *ProxyAPIProvider) Health() error {
+	req, err := http.NewRequest("GET", p.BaseURL+"/api/v1/protected/sberchat/health", nil)
+	if err != nil {
+		return fmt.Errorf("ошибка создания health check запроса: %w", err)
+	}
+
+	if p.JWTToken != "" {
+		req.Header.Set("Authorization", "Bearer "+p.JWTToken)
+	}
+
+	resp, err := p.HTTPClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("ошибка health check: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("health check failed: %d", resp.StatusCode)
+	}
+
+	var healthResponse ProxyHealthResponse
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("ошибка чтения health check ответа: %w", err)
+	}
+
+	if err := json.Unmarshal(body, &healthResponse); err != nil {
+		return fmt.Errorf("ошибка парсинга health check ответа: %w", err)
+	}
+
+	if healthResponse.Status != "ok" {
+		return fmt.Errorf("health check status: %s - %s", healthResponse.Status, healthResponse.Message)
+	}
+
+	return nil
+}
+
+// Chat для OllamaProvider
+func (o *OllamaProvider) Chat(messages []Chat) (string, error) {
+	payload := Gpt3Request{
+		Model:    o.Model,
+		Messages: messages,
+		Stream:   false,
+		Options:  Gpt3Options{o.Temperature},
+	}
+
+	jsonData, err := json.Marshal(payload)
+	if err != nil {
+		return "", fmt.Errorf("ошибка маршалинга запроса: %w", err)
+	}
+
+	req, err := http.NewRequest("POST", o.BaseURL+"/api/chat", bytes.NewBuffer(jsonData))
+	if err != nil {
+		return "", fmt.Errorf("ошибка создания запроса: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := o.HTTPClient.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("ошибка выполнения запроса: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("ошибка чтения ответа: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("ошибка API: %d - %s", resp.StatusCode, string(body))
+	}
+
+	var response OllamaResponse
+	if err := json.Unmarshal(body, &response); err != nil {
+		return "", fmt.Errorf("ошибка парсинга ответа: %w", err)
+	}
+
+	return strings.TrimSpace(response.Message.Content), nil
+}
+
+// Health для OllamaProvider
+func (o *OllamaProvider) Health() error {
+	req, err := http.NewRequest("GET", o.BaseURL+"/api/tags", nil)
+	if err != nil {
+		return fmt.Errorf("ошибка создания health check запроса: %w", err)
+	}
+
+	resp, err := o.HTTPClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("ошибка health check: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("health check failed: %d", resp.StatusCode)
+	}
+
+	return nil
+}
+
+// GetAvailableModels для ProxyAPIProvider возвращает фиксированный список
+func (p *ProxyAPIProvider) GetAvailableModels() ([]string, error) {
+	return []string{"GigaChat-2", "GigaChat-2-Pro", "GigaChat-2-Max"}, nil
+}
+
+// GetAvailableModels возвращает список доступных моделей для провайдера
+func (o *OllamaProvider) GetAvailableModels() ([]string, error) {
+	req, err := http.NewRequest("GET", o.BaseURL+"/api/tags", nil)
+	if err != nil {
+		return nil, fmt.Errorf("ошибка создания запроса: %w", err)
+	}
+
+	resp, err := o.HTTPClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("ошибка получения моделей: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("ошибка чтения ответа: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("ошибка API: %d - %s", resp.StatusCode, string(body))
+	}
+
+	var response OllamaTagsResponse
+	if err := json.Unmarshal(body, &response); err != nil {
+		return nil, fmt.Errorf("ошибка парсинга ответа: %w", err)
+	}
+
+	var models []string
+	for _, model := range response.Models {
+		models = append(models, model.Name)
+	}
+
+	return models, nil
+}

main.go

@@ -5,8 +5,10 @@ import (
 	"fmt"
 	"math"
 	"os"
+	"os/exec"
 	"os/user"
 	"path"
+	"strconv"
 	"strings"
 	"time"
 
@@ -27,33 +29,46 @@ var (
 	PROMPT        = getEnv("LCG_PROMPT", "Reply with linux command and nothing else. Output with plain response - no need formatting. No need explanation. No need code blocks. No need ` symbols.")
 	API_KEY_FILE  = getEnv("LCG_API_KEY_FILE", ".openai_api_key")
 	RESULT_FOLDER = getEnv("LCG_RESULT_FOLDER", path.Join(cwd, "gpt_results"))
+	PROVIDER_TYPE = getEnv("LCG_PROVIDER", "ollama") // "ollama", "proxy"
+	JWT_TOKEN     = getEnv("LCG_JWT_TOKEN", "")
+	PROMPT_ID     = getEnv("LCG_PROMPT_ID", "1") // ID промпта по умолчанию
+	TIMEOUT       = getEnv("LCG_TIMEOUT", "120") // Таймаут в секундах по умолчанию
+)
+
+const (
+	colorRed    = "\033[31m"
+	colorGreen  = "\033[32m"
+	colorYellow = "\033[33m"
+	colorBlue   = "\033[34m"
+	colorPurple = "\033[35m"
+	colorCyan   = "\033[36m"
+	colorReset  = "\033[0m"
+	colorBold   = "\033[1m"
 )
 
 func main() {
 	app := &cli.App{
 		Name:     "lcg",
-		Usage:    "Linux Command GPT - Generate Linux commands from descriptions",
+		Usage:    "Linux Command GPT - Генерация Linux команд из описаний",
 		Version:  Version,
 		Commands: getCommands(),
 		UsageText: `
-lcg [global options] <command description>
+lcg [опции] <описание команды>
 
-Examples:
+Примеры:
-  lcg "I want to extract linux-command-gpt.tar.gz file"
+  lcg "хочу извлечь файл linux-command-gpt.tar.gz"
-  lcg --file /path/to/file.txt "I want to list all directories with ls"
+  lcg --file /path/to/file.txt "хочу вывести все директории с помощью ls"
 `,
 		Description: `
-Linux Command GPT is a tool for generating Linux commands from natural language descriptions. 
+Linux Command GPT - инструмент для генерации Linux команд из описаний на естественном языке.
-It supports reading parts of the prompt from files and allows saving, copying, or regenerating results.
+Поддерживает чтение частей промпта из файлов и позволяет сохранять, копировать или перегенерировать результаты.
-Additional commands are available for managing API keys.
 
-Environment Variables:
+Переменные окружения:
-  LCG_HOST          Endpoint for LLM API (default: http://192.168.87.108:11434/)
+  LCG_HOST          Endpoint для LLM API (по умолчанию: http://192.168.87.108:11434/)
-  LCG_COMPLETIONS_PATH  Relative API path (default: api/chat)
+  LCG_MODEL         Название модели (по умолчанию: codegeex4)
-  LCG_MODEL         Model name (default: codegeex4)
+  LCG_PROMPT        Текст промпта по умолчанию
-  LCG_PROMPT        Default prompt text
+  LCG_PROVIDER      Тип провайдера: "ollama" или "proxy" (по умолчанию: ollama)
-  LCG_API_KEY_FILE  API key storage file (default: ~/.openai_api_key)
+  LCG_JWT_TOKEN     JWT токен для proxy провайдера
-  LCG_RESULT_FOLDER Results folder (default: ./gpt_results)
 `,
 		Flags: []cli.Flag{
 			&cli.StringFlag{
@@ -64,20 +79,50 @@ Environment Variables:
 			&cli.StringFlag{
 				Name:        "sys",
 				Aliases:     []string{"s"},
-				Usage:       "System prompt",
+				Usage:       "System prompt content or ID",
-				DefaultText: getEnv("LCG_PROMPT", "Reply with linux command and nothing else. Output with plain response - no need formatting. No need explanation. No need code blocks"),
+				DefaultText: "Use prompt ID from LCG_PROMPT_ID or default prompt",
-				Value:       getEnv("LCG_PROMPT", "Reply with linux command and nothing else. Output with plain response - no need formatting. No need explanation. No need code blocks"),
+				Value:       "",
+			},
+			&cli.IntFlag{
+				Name:        "prompt-id",
+				Aliases:     []string{"pid"},
+				Usage:       "System prompt ID (1-5 for default prompts)",
+				DefaultText: "1",
+				Value:       1,
+			},
+			&cli.IntFlag{
+				Name:        "timeout",
+				Aliases:     []string{"t"},
+				Usage:       "Request timeout in seconds",
+				DefaultText: "120",
+				Value:       120,
 			},
 		},
 		Action: func(c *cli.Context) error {
 			file := c.String("file")
 			system := c.String("sys")
+			promptID := c.Int("prompt-id")
+			timeout := c.Int("timeout")
 			args := c.Args().Slice()
+
 			if len(args) == 0 {
 				cli.ShowAppHelp(c)
+				showTips()
 				return nil
 			}
-			executeMain(file, system, strings.Join(args, " "))
+
+			// Если указан prompt-id, загружаем соответствующий промпт
+			if system == "" && promptID > 0 {
+				currentUser, _ := user.Current()
+				pm := gpt.NewPromptManager(currentUser.HomeDir)
+				if prompt, err := pm.GetPromptByID(promptID); err == nil {
+					system = prompt.Content
+				} else {
+					fmt.Printf("Warning: Prompt ID %d not found, using default prompt\n", promptID)
+				}
+			}
+
+			executeMain(file, system, strings.Join(args, " "), timeout)
 			return nil
 		},
 	}
@@ -104,7 +149,15 @@ func getCommands() []*cli.Command {
 			Aliases: []string{"u"},
 			Usage:   "Update the API key",
 			Action: func(c *cli.Context) error {
-				gpt3 := initGPT()
+				if PROVIDER_TYPE == "ollama" || PROVIDER_TYPE == "proxy" {
+					fmt.Println("API key is not needed for ollama and proxy providers")
+					return nil
+				}
+				timeout := 120 // default timeout
+				if t, err := strconv.Atoi(TIMEOUT); err == nil {
+					timeout = t
+				}
+				gpt3 := initGPT(PROMPT, timeout)
 				gpt3.UpdateKey()
 				fmt.Println("API key updated.")
 				return nil
@@ -115,69 +168,337 @@ func getCommands() []*cli.Command {
 			Aliases: []string{"d"},
 			Usage:   "Delete the API key",
 			Action: func(c *cli.Context) error {
-				gpt3 := initGPT()
+				if PROVIDER_TYPE == "ollama" || PROVIDER_TYPE == "proxy" {
+					fmt.Println("API key is not needed for ollama and proxy providers")
+					return nil
+				}
+				timeout := 120 // default timeout
+				if t, err := strconv.Atoi(TIMEOUT); err == nil {
+					timeout = t
+				}
+				gpt3 := initGPT(PROMPT, timeout)
 				gpt3.DeleteKey()
 				fmt.Println("API key deleted.")
 				return nil
 			},
 		},
+		{
+			Name:    "update-jwt",
+			Aliases: []string{"j"},
+			Usage:   "Update the JWT token for proxy API",
+			Action: func(c *cli.Context) error {
+				if PROVIDER_TYPE != "proxy" {
+					fmt.Println("JWT token is only needed for proxy provider")
+					return nil
+				}
+
+				var jwtToken string
+				fmt.Print("JWT Token: ")
+				fmt.Scanln(&jwtToken)
+
+				currentUser, _ := user.Current()
+				jwtFile := currentUser.HomeDir + "/.proxy_jwt_token"
+				if err := os.WriteFile(jwtFile, []byte(strings.TrimSpace(jwtToken)), 0600); err != nil {
+					fmt.Printf("Ошибка сохранения JWT токена: %v\n", err)
+					return err
+				}
+
+				fmt.Println("JWT token updated.")
+				return nil
+			},
+		},
+		{
+			Name:    "delete-jwt",
+			Aliases: []string{"dj"},
+			Usage:   "Delete the JWT token for proxy API",
+			Action: func(c *cli.Context) error {
+				if PROVIDER_TYPE != "proxy" {
+					fmt.Println("JWT token is only needed for proxy provider")
+					return nil
+				}
+
+				currentUser, _ := user.Current()
+				jwtFile := currentUser.HomeDir + "/.proxy_jwt_token"
+				if err := os.Remove(jwtFile); err != nil && !os.IsNotExist(err) {
+					fmt.Printf("Ошибка удаления JWT токена: %v\n", err)
+					return err
+				}
+
+				fmt.Println("JWT token deleted.")
+				return nil
+			},
+		},
+		{
+			Name:    "models",
+			Aliases: []string{"m"},
+			Usage:   "Show available models",
+			Action: func(c *cli.Context) error {
+				timeout := 120 // default timeout
+				if t, err := strconv.Atoi(TIMEOUT); err == nil {
+					timeout = t
+				}
+				gpt3 := initGPT(PROMPT, timeout)
+				models, err := gpt3.GetAvailableModels()
+				if err != nil {
+					fmt.Printf("Ошибка получения моделей: %v\n", err)
+					return err
+				}
+
+				fmt.Printf("Доступные модели для провайдера %s:\n", PROVIDER_TYPE)
+				for i, model := range models {
+					fmt.Printf("  %d. %s\n", i+1, model)
+				}
+				return nil
+			},
+		},
+		{
+			Name:    "health",
+			Aliases: []string{"he"}, // Изменено с "h" на "he"
+			Usage:   "Check API health",
+			Action: func(c *cli.Context) error {
+				timeout := 120 // default timeout
+				if t, err := strconv.Atoi(TIMEOUT); err == nil {
+					timeout = t
+				}
+				gpt3 := initGPT(PROMPT, timeout)
+				if err := gpt3.Health(); err != nil {
+					fmt.Printf("Health check failed: %v\n", err)
+					return err
+				}
+				fmt.Println("API is healthy.")
+				return nil
+			},
+		},
+		{
+			Name:    "config",
+			Aliases: []string{"co"}, // Изменено с "c" на "co"
+			Usage:   "Show current configuration",
+			Action: func(c *cli.Context) error {
+				fmt.Printf("Provider: %s\n", PROVIDER_TYPE)
+				fmt.Printf("Host: %s\n", HOST)
+				fmt.Printf("Model: %s\n", MODEL)
+				fmt.Printf("Prompt: %s\n", PROMPT)
+				fmt.Printf("Timeout: %s seconds\n", TIMEOUT)
+				if PROVIDER_TYPE == "proxy" {
+					fmt.Printf("JWT Token: %s\n", func() string {
+						if JWT_TOKEN != "" {
+							return "***set***"
+						}
+						currentUser, _ := user.Current()
+						jwtFile := currentUser.HomeDir + "/.proxy_jwt_token"
+						if _, err := os.Stat(jwtFile); err == nil {
+							return "***from file***"
+						}
+						return "***not set***"
+					}())
+				}
+				return nil
+			},
+		},
+		{
+			Name:    "history",
+			Aliases: []string{"hist"},
+			Usage:   "Show command history",
+			Action: func(c *cli.Context) error {
+				showHistory()
+				return nil
+			},
+		},
+		{
+			Name:    "prompts",
+			Aliases: []string{"p"},
+			Usage:   "Manage system prompts",
+			Subcommands: []*cli.Command{
+				{
+					Name:    "list",
+					Aliases: []string{"l"},
+					Usage:   "List all available prompts",
+					Action: func(c *cli.Context) error {
+						currentUser, _ := user.Current()
+						pm := gpt.NewPromptManager(currentUser.HomeDir)
+						pm.ListPrompts()
+						return nil
+					},
+				},
+				{
+					Name:    "add",
+					Aliases: []string{"a"},
+					Usage:   "Add a new custom prompt",
+					Action: func(c *cli.Context) error {
+						currentUser, _ := user.Current()
+						pm := gpt.NewPromptManager(currentUser.HomeDir)
+
+						var name, description, content string
+
+						fmt.Print("Название промпта: ")
+						fmt.Scanln(&name)
+
+						fmt.Print("Описание: ")
+						fmt.Scanln(&description)
+
+						fmt.Print("Содержание промпта: ")
+						fmt.Scanln(&content)
+
+						if err := pm.AddCustomPrompt(name, description, content); err != nil {
+							fmt.Printf("Ошибка добавления промпта: %v\n", err)
+							return err
+						}
+
+						fmt.Println("Промпт успешно добавлен!")
+						return nil
+					},
+				},
+				{
+					Name:    "delete",
+					Aliases: []string{"d"},
+					Usage:   "Delete a custom prompt",
+					Action: func(c *cli.Context) error {
+						if c.NArg() == 0 {
+							fmt.Println("Укажите ID промпта для удаления")
+							return nil
+						}
+
+						var id int
+						if _, err := fmt.Sscanf(c.Args().First(), "%d", &id); err != nil {
+							fmt.Println("Неверный ID промпта")
+							return err
+						}
+
+						currentUser, _ := user.Current()
+						pm := gpt.NewPromptManager(currentUser.HomeDir)
+
+						if err := pm.DeleteCustomPrompt(id); err != nil {
+							fmt.Printf("Ошибка удаления промпта: %v\n", err)
+							return err
+						}
+
+						fmt.Println("Промпт успешно удален!")
+						return nil
+					},
+				},
+			},
+		},
+		{
+			Name:    "test-prompt",
+			Aliases: []string{"tp"},
+			Usage:   "Test a specific prompt ID",
+			Action: func(c *cli.Context) error {
+				if c.NArg() == 0 {
+					fmt.Println("Usage: lcg test-prompt <prompt-id> <command>")
+					return nil
+				}
+
+				var promptID int
+				if _, err := fmt.Sscanf(c.Args().First(), "%d", &promptID); err != nil {
+					fmt.Println("Invalid prompt ID")
+					return err
+				}
+
+				currentUser, _ := user.Current()
+				pm := gpt.NewPromptManager(currentUser.HomeDir)
+
+				prompt, err := pm.GetPromptByID(promptID)
+				if err != nil {
+					fmt.Printf("Prompt ID %d not found\n", promptID)
+					return err
+				}
+
+				fmt.Printf("Testing prompt ID %d: %s\n", promptID, prompt.Name)
+				fmt.Printf("Description: %s\n", prompt.Description)
+				fmt.Printf("Content: %s\n", prompt.Content)
+
+				if len(c.Args().Slice()) > 1 {
+					command := strings.Join(c.Args().Slice()[1:], " ")
+					fmt.Printf("\nTesting with command: %s\n", command)
+					timeout := 120 // default timeout
+					if t, err := strconv.Atoi(TIMEOUT); err == nil {
+						timeout = t
+					}
+					executeMain("", prompt.Content, command, timeout)
+				}
+
+				return nil
+			},
+		},
 	}
 }
 
-func executeMain(file, system, commandInput string) {
+func executeMain(file, system, commandInput string, timeout int) {
-	// fmt.Println(system, commandInput)
-	// os.Exit(0)
 	if file != "" {
 		if err := reader.FileToPrompt(&commandInput, file); err != nil {
-			fmt.Println("Error reading file:", err)
+			printColored(fmt.Sprintf("❌ Ошибка чтения файла: %v\n", err), colorRed)
 			return
 		}
 	}
 
-	if _, err := os.Stat(RESULT_FOLDER); os.IsNotExist(err) {
+	// Если system пустой, используем дефолтный промпт
-		os.MkdirAll(RESULT_FOLDER, 0755)
+	if system == "" {
+		system = PROMPT
 	}
 
-	gpt3 := initGPT()
+	if _, err := os.Stat(RESULT_FOLDER); os.IsNotExist(err) {
+		if err := os.MkdirAll(RESULT_FOLDER, 0755); err != nil {
+			printColored(fmt.Sprintf("❌ Ошибка создания папки результатов: %v\n", err), colorRed)
+			return
+		}
+	}
+
+	gpt3 := initGPT(system, timeout)
+
+	printColored("🤖 Запрос: ", colorCyan)
+	fmt.Printf("%s\n", commandInput)
 
 	response, elapsed := getCommand(gpt3, commandInput)
 	if response == "" {
-		fmt.Println("No response received.")
+		printColored("❌ Ответ не получен. Проверьте подключение к API.\n", colorRed)
 		return
 	}
 
-	fmt.Printf("Completed in %v seconds\n\n%s\n", elapsed, response)
+	printColored(fmt.Sprintf("✅ Выполнено за %.2f сек\n", elapsed), colorGreen)
+	printColored("\n📋 Команда:\n", colorYellow)
+	printColored(fmt.Sprintf("   %s\n\n", response), colorBold+colorGreen)
+
+	saveToHistory(commandInput, response)
 	handlePostResponse(response, gpt3, system, commandInput)
 }
 
-func initGPT() gpt.Gpt3 {
+func initGPT(system string, timeout int) gpt.Gpt3 {
 	currentUser, _ := user.Current()
-	return gpt.Gpt3{
+
-		CompletionUrl: HOST + COMPLETIONS,
+	// Загружаем JWT токен в зависимости от провайдера
-		Model:         MODEL,
+	var jwtToken string
-		Prompt:        PROMPT,
+	if PROVIDER_TYPE == "proxy" {
-		HomeDir:       currentUser.HomeDir,
+		jwtToken = JWT_TOKEN
-		ApiKeyFile:    API_KEY_FILE,
+		if jwtToken == "" {
-		Temperature:   0.01,
+			// Пытаемся загрузить из файла
+			jwtFile := currentUser.HomeDir + "/.proxy_jwt_token"
+			if data, err := os.ReadFile(jwtFile); err == nil {
+				jwtToken = strings.TrimSpace(string(data))
+			}
+		}
 	}
+
+	return *gpt.NewGpt3(PROVIDER_TYPE, HOST, jwtToken, MODEL, system, 0.01, timeout)
 }
 
 func getCommand(gpt3 gpt.Gpt3, cmd string) (string, float64) {
 	gpt3.InitKey()
 	start := time.Now()
 	done := make(chan bool)
+
 	go func() {
-		loadingChars := []rune{'-', '\\', '|', '/'}
+		loadingChars := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
 		i := 0
 		for {
 			select {
 			case <-done:
-				fmt.Printf("\r")
+				fmt.Printf("\r%s", strings.Repeat(" ", 50))
+				fmt.Print("\r")
 				return
 			default:
-				fmt.Printf("\rLoading %c", loadingChars[i])
+				fmt.Printf("\r%s Обрабатываю запрос...", loadingChars[i])
 				i = (i + 1) % len(loadingChars)
-				time.Sleep(30 * time.Millisecond)
+				time.Sleep(100 * time.Millisecond)
 			}
 		}
 	}()
@@ -190,20 +511,23 @@ func getCommand(gpt3 gpt.Gpt3, cmd string) (string, float64) {
 }
 
 func handlePostResponse(response string, gpt3 gpt.Gpt3, system, cmd string) {
-	fmt.Print("\nOptions: (c)opy, (s)ave, (r)egenerate, (n)one: ")
+	fmt.Printf("Действия: (c)копировать, (s)сохранить, (r)перегенерировать, (e)выполнить, (n)ничего: ")
 	var choice string
 	fmt.Scanln(&choice)
 
 	switch strings.ToLower(choice) {
 	case "c":
 		clipboard.WriteAll(response)
-		fmt.Println("Response copied to clipboard.")
+		fmt.Println("✅ Команда скопирована в буфер обмена")
 	case "s":
 		saveResponse(response, gpt3, cmd)
 	case "r":
-		executeMain("", system, cmd)
+		fmt.Println("🔄 Перегенерирую...")
+		executeMain("", system, cmd, 120) // Use default timeout for regeneration
+	case "e":
+		executeCommand(response)
 	default:
-		fmt.Println("No action taken.")
+		fmt.Println(" До свидания!")
 	}
 }
 
@@ -220,9 +544,83 @@ func saveResponse(response string, gpt3 gpt.Gpt3, cmd string) {
 	}
 }
 
+func executeCommand(command string) {
+	fmt.Printf("🚀 Выполняю: %s\n", command)
+	fmt.Print("Продолжить? (y/N): ")
+	var confirm string
+	fmt.Scanln(&confirm)
+
+	if strings.ToLower(confirm) == "y" || strings.ToLower(confirm) == "yes" {
+		cmd := exec.Command("bash", "-c", command)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+
+		if err := cmd.Run(); err != nil {
+			fmt.Printf("❌ Ошибка выполнения: %v\n", err)
+		} else {
+			fmt.Println("✅ Команда выполнена успешно")
+		}
+	} else {
+		fmt.Println("❌ Выполнение отменено")
+	}
+}
+
 func getEnv(key, defaultValue string) string {
 	if value, exists := os.LookupEnv(key); exists {
 		return value
 	}
 	return defaultValue
 }
+
+type CommandHistory struct {
+	Command   string
+	Response  string
+	Timestamp time.Time
+}
+
+var commandHistory []CommandHistory
+
+func saveToHistory(cmd, response string) {
+	commandHistory = append(commandHistory, CommandHistory{
+		Command:   cmd,
+		Response:  response,
+		Timestamp: time.Now(),
+	})
+
+	// Ограничиваем историю 100 командами
+	if len(commandHistory) > 100 {
+		commandHistory = commandHistory[1:]
+	}
+}
+
+func showHistory() {
+	if len(commandHistory) == 0 {
+		printColored("📝 История пуста\n", colorYellow)
+		return
+	}
+
+	printColored("📝 История команд:\n", colorYellow)
+	for i, hist := range commandHistory {
+		fmt.Printf("%d. %s → %s (%s)\n",
+			i+1,
+			hist.Command,
+			hist.Response,
+			hist.Timestamp.Format("15:04:05"))
+	}
+}
+
+func printColored(text, color string) {
+	fmt.Printf("%s%s%s", color, text, colorReset)
+}
+
+func showTips() {
+	printColored("💡 Подсказки:\n", colorCyan)
+	fmt.Println("   • Используйте --file для чтения из файла")
+	fmt.Println("   • Используйте --sys для изменения системного промпта")
+	fmt.Println("   • Используйте --prompt-id для выбора предустановленного промпта")
+	fmt.Println("   • Используйте --timeout для установки таймаута запроса")
+	fmt.Println("   • Команда 'prompts list' покажет все доступные промпты")
+	fmt.Println("   • Команда 'history' покажет историю запросов")
+	fmt.Println("   • Команда 'config' покажет текущие настройки")
+	fmt.Println("   • Команда 'health' проверит доступность API")
+}

shell-code/build-full.sh

@@ -1,92 +1,134 @@
 #!/bin/bash
 
-# REPO=registry.direct-dev.ru/go-lcg
+# Включаем строгий режим для лучшей отладки
-REPO=kuznetcovay/go-lcg
+set -euo pipefail
-VERSION=$1
-if [ -z "$VERSION" ]; then
-    VERSION=v1.0.1
-fi
-BRANCH=main
 
-echo ${VERSION} > VERSION.txt
+# Конфигурация
+readonly REPO="kuznetcovay/go-lcg"
+readonly BRANCH="main"
+readonly BINARY_NAME="lcg"
 
-export GOCACHE="${HOME}/.cache/go-build"
+# Получаем версию из аргумента или используем значение по умолчанию
+VERSION="${1:-v1.1.0}"
 
-# Save the current branch
+# Цвета для вывода
-CURRENT_BRANCH=$(git branch --show-current)
+readonly RED='\033[0;31m'
+readonly GREEN='\033[0;32m'
+readonly YELLOW='\033[1;33m'
+readonly NC='\033[0m' # No Color
 
-# Function to restore the original branch
+# Функции для логирования
-function restore_branch {
+log_info() {
-        echo "Restoring original branch: ${CURRENT_BRANCH}"
+    echo -e "${GREEN}[INFO]${NC} $1"
-        git checkout "${CURRENT_BRANCH}"
 }
 
-# Check if the current branch is different from the target branch
+log_warn() {
-if [ "$CURRENT_BRANCH" != "$BRANCH" ]; then
+    echo -e "${YELLOW}[WARN]${NC} $1"
-        # Set a trap to restore the branch on exit
+}
-        trap restore_branch EXIT
-        echo "Switching to branch: ${BRANCH}"
-        git checkout ${BRANCH}
-fi
 
-# Fetch all tags from the remote repository
+log_error() {
-git fetch --tags
+    echo -e "${RED}[ERROR]${NC} $1"
+}
 
-# Check if the specified version tag exists
+# Функция для обработки ошибок
-if git rev-parse "refs/tags/${VERSION}" >/dev/null 2>&1; then
+handle_error() {
-        echo "Tag ${VERSION} already exists. Halting script."
+    local exit_code=$?
+    log_error "Скрипт завершился с ошибкой (код: $exit_code)"
+    exit $exit_code
+}
+
+# Функция для восстановления ветки
+restore_branch() {
+    if [[ -n "${CURRENT_BRANCH:-}" ]]; then
+        log_info "Восстанавливаем исходную ветку: ${CURRENT_BRANCH}"
+        git checkout "${CURRENT_BRANCH}" || log_warn "Не удалось переключиться на ${CURRENT_BRANCH}"
+    fi
+}
+
+# Функция для сборки бинарного файла
+build_binary() {
+    local platform=$1
+    local output_dir="bin-linux-${platform}"
+    local dockerfile="Dockerfiles/LocalCompile/Dockerfile"
+    
+    log_info "Собираем для ${platform}..."
+    
+    if docker build -f "$dockerfile" --target bin-linux --output "$output_dir/" --platform "linux/${platform}" .; then
+        cp "$output_dir/$BINARY_NAME" "binaries-for-upload/$BINARY_NAME.${platform}.${VERSION}"
+        log_info "Сборка для ${platform} завершена успешно"
+    else
+        log_error "Сборка для ${platform} не удалась"
+        return 1
+    fi
+}
+
+# Функция для git операций
+git_operations() {
+    log_info "Выполняем git операции..."
+    
+    git add -A . || { log_error "git add не удался"; return 1; }
+    git commit -m "release $VERSION" || { log_error "git commit не удался"; return 1; }
+    git tag -a "$VERSION" -m "release $VERSION" || { log_error "git tag не удался"; return 1; }
+    git push -u origin main --tags || { log_error "git push не удался"; return 1; }
+    
+    log_info "Git операции завершены успешно"
+}
+
+# Основная функция
+main() {
+    log_info "Начинаем сборку версии: $VERSION"
+    
+    # Записываем версию в файл
+    echo "$VERSION" > VERSION.txt
+    
+    # Настраиваем кэш Go
+    export GOCACHE="${HOME}/.cache/go-build"
+    
+    # Сохраняем текущую ветку
+    CURRENT_BRANCH=$(git branch --show-current)
+    
+    # Настраиваем обработчик ошибок
+    trap handle_error ERR
+    trap restore_branch EXIT
+    
+    # Переключаемся на нужную ветку если необходимо
+    if [[ "$CURRENT_BRANCH" != "$BRANCH" ]]; then
+        log_info "Переключаемся на ветку: $BRANCH"
+        git checkout "$BRANCH"
+    fi
+    
+    # Получаем теги
+    log_info "Получаем теги из удаленного репозитория..."
+    git fetch --tags
+    
+    # Проверяем существование тега
+    if git rev-parse "refs/tags/${VERSION}" >/dev/null 2>&1; then
+        log_error "Тег ${VERSION} уже существует. Прерываем выполнение."
         exit 1
-fi
+    fi
+    
+    # Создаем директорию для бинарных файлов
+    mkdir -p binaries-for-upload
+    
+    # Собираем бинарные файлы для обеих платформ
+    build_binary "amd64"
+    build_binary "arm64"
+    
+    # Собираем и пушим Docker образы
+    log_info "Собираем и пушим multi-platform Docker образы..."
+    if docker buildx build -f Dockerfiles/ImageBuild/Dockerfile --push --platform linux/amd64,linux/arm64 -t "${REPO}:${VERSION}" .; then
+        log_info "Docker образы успешно собраны и запушены"
+    else
+        log_error "Сборка Docker образов не удалась"
+        exit 1
+    fi
+    
+    # Выполняем git операции
+    git_operations
+    
+    log_info "Сборка версии $VERSION завершена успешно!"
+}
 
-# Run go tests
+# Запускаем основную функцию
-# if ! go test -v -run=^Test; then
+main "$@"
-#         echo "Tests failed. Exiting..."
-#         exit 1
-# fi
-mkdir binaries-for-upload
-# Build for linux/amd64
-docker build -f Dockerfiles/LocalCompile/Dockerfile --target bin-linux --output bin-linux-amd64/ --platform linux/amd64 . ||
-        {
-                echo "docker build for amd64 failed. Exiting with code 1."
-                exit 1
-        }
-
-cp bin-linux-amd64/lcg  "binaries-for-upload/lcg.amd64.${VERSION}"
-
-# Build for linux/arm64
-docker build -f Dockerfiles/LocalCompile/Dockerfile --target bin-linux --output bin-linux-arm64/ --platform linux/arm64 . ||
-        {
-                echo "docker build for arm64 failed. Exiting with code 1."
-                exit 1
-        }
-
-cp bin-linux-arm64/lcg  "binaries-for-upload/lcg.arm64.${VERSION}"
-
-# Push multi-platform images
-docker buildx build -f Dockerfiles/ImageBuild/Dockerfile --push --platform linux/amd64,linux/arm64 -t ${REPO}:"${VERSION}" . ||
-        {
-                echo "docker buildx build --push failed. Exiting with code 1."
-                exit 1
-        }
-
-git add -A . ||
-        {
-                echo "git add failed. Exiting with code 1."
-                exit 1
-        }
-git commit -m "release $VERSION" ||
-        {
-                echo "git commit failed. Exiting with code 1."
-                exit 1
-        }
-git tag -a "$VERSION" -m "release $VERSION" ||
-        {
-                echo "git tag failed. Exiting with code 1."
-                exit 1
-        }
-git push -u origin main --tags ||
-        {
-                echo "git push failed. Exiting with code 1."
-                exit 1
-        }
 

shell-code/run-with-proxy.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/bash
+
+# shellcheck disable=SC2034
+LCG_PROVIDER=proxy LCG_HOST=http://localhost:8080 LCG_MODEL=GigaChat-2-Max LCG_JWT_TOKEN=$(go-ansible-vault -a -i shell-code/jwt.admin.token get -m 'JWT_TOKEN' -q) go run . $1 $2 $3 $4 $5 $6 $7 $8 $9
+
+LCG_PROVIDER=proxy LCG_HOST=https://direct-dev.ru LCG_MODEL=GigaChat-2-Max LCG_JWT_TOKEN=$(go-ansible-vault --key $(cat ~/.config/gak)  -i ~/.config/jwt.direct-dev.ru get -m 'JWT_TOKEN' -q) go run . [your question here]