feat: Universal CLI

chebread · chebread · commit 488a71c55f8f · 2026-02-18T20:38:16.000+09:00
diff --git a/README.md b/README.md
@@ -255,6 +255,7 @@ It adapts to your workspace, not the other way around.
 To use lx, you need both the CLI tool and the Go library. Here is the straightforward setup for any Gopher.
 
 ## 1. Install the CLI
+
 `lx` is deployed via Homebrew for macOS.
 
 ```bash
@@ -267,24 +268,79 @@ brew install lx
 > Currently, only macOS (Intel/Apple Silicon) is supported.
 
 ## 2. Add the Library to your Project
+
 Add the dependency to your project to use `lx.Gen()` in your code.
 
 ```bash
 go get github.com/chebread/lx
+
 ```
 
 ## 3. Configuration
 
 Create an `lx-config.yaml` file in your home directory (`~/`) or project root.
+`lx` supports two modes: Direct API and Universal Command.
+
+### Option A: Direct API (Google Gemini)
+
+The simplest setup if you have a Google API Key.
 
 ```yaml
 provider: "gemini"
 api_key: "YOUR_API_KEY"
-model: "foo_bar" 
+model: "gemini-2.0-flash"
+
 ```
 
-> [!NOTE]
-> Currently, only Google Gemini is supported.
+### Option B: Universal CLI (Gemini, Claude, Ollama, etc.)
+
+`lx` can wrap any CLI tool installed on your machine.
+Use the `command` provider and define the argument template. `lx` will automatically substitute `{{prompt}}` and `{{model}}` at runtime.
+
+#### 1. Google Gemini CLI (Zero Cost / No API Key in Config)
+
+```yaml
+provider: "command"
+bin_path: "/usr/local/bin/gemini" # Check with `which gemini`
+model: "gemini-2.0-flash"
+args:
+  - "-p"
+  - "{{prompt}}"
+  - "-m"
+  - "{{model}}"
+  - "-o"
+  - "text"
+
+```
+
+#### 2. Claude Code (Anthropic)
+
+```yaml
+provider: "command"
+bin_path: "/usr/local/bin/claude"
+model: "claude-3-7-sonnet"
+args:
+  - "-p"
+  - "{{prompt}}"
+  - "--model"
+  - "{{model}}"
+
+```
+
+#### 3. Ollama (Local / Offline / Free)
+
+Run Llama 3 or DeepSeek locally without internet.
+
+```yaml
+provider: "command"
+bin_path: "/usr/local/bin/ollama"
+model: "llama3"
+args:
+  - "run"
+  - "{{model}}"
+  - "{{prompt}}"
+
+```
 
 ---
 
diff --git a/cmd/main.go b/cmd/main.go
@@ -33,10 +33,11 @@ import (
 var version = "dev"
 
 type Config struct {
-	Provider string `yaml:"provider"`
-	ApiKey   string `yaml:"api_key"`
-	Model    string `yaml:"model"`
-	BinPath  string `yaml:"bin_path"` // <-- [수정 1] 이 줄을 추가하세요
+	Provider string   `yaml:"provider"`
+	ApiKey   string   `yaml:"api_key"`
+	Model    string   `yaml:"model"`
+	BinPath  string   `yaml:"bin_path"`
+	Args     []string `yaml:"args"`
 }
 
 type TargetInfo struct {
@@ -71,6 +72,7 @@ type options struct {
 
 type commandLLM struct {
 	binPath string
+	args    []string // <-- [수정 2] 템플릿 저장용 필드 추가
 }
 
 func main() {
@@ -137,8 +139,6 @@ func main() {
 	clear(backups)
 
 	if err != nil {
-		// 에러가 났으므로 즉시 소스를 원래대로 돌려놓고 종료합니다.
-		// (log.Fatalf는 os.Exit을 호출하므로 defer가 실행되지 않을 수 있어 수동 복구합니다)
 		revertCode(backups)
 		log.Fatalf("\n[lx] Stop: Execution failed. Fix your Go code first.\nError: %v", err)
 	}
@@ -208,12 +208,9 @@ func injectSpyCode(root string) (map[string]fileBackup, error) {
 				return true
 			}
 
-			// 1. 함수의 반환 타입들을 순서대로 추출합니다.
-			// 예: func foo() (int, error) -> [int, error]
 			var returnTypes []ast.Expr
 			if fn.Type.Results != nil {
 				for _, field := range fn.Type.Results.List {
-					// 이름이 있는 반환값 (a, b int) 또는 없는 반환값 (int, int) 처리
 					count := len(field.Names)
 					if count == 0 {
 						count = 1
@@ -227,7 +224,6 @@ func injectSpyCode(root string) (map[string]fileBackup, error) {
 			isVoid := len(returnTypes) == 0
 
 			if isVoid {
-				// [Void 함수 처리] SpyVoid 사용 (기존과 동일)
 				deferStmt := &ast.DeferStmt{
 					Call: &ast.CallExpr{
 						Fun: &ast.SelectorExpr{
@@ -245,38 +241,29 @@ func injectSpyCode(root string) (map[string]fileBackup, error) {
 				fn.Body.List = append([]ast.Stmt{deferStmt}, fn.Body.List...)
 				modified = true
 			} else {
-				// [반환값이 있는 함수 처리]
 				ast.Inspect(fn.Body, func(inner ast.Node) bool {
 					retStmt, ok := inner.(*ast.ReturnStmt)
 					if !ok {
 						return true
 					}
 
 					for i, resultExpr := range retStmt.Results {
-						// 인덱스 안전장치 및 이미 Spy 처리된 것 스킵
 						if i >= len(returnTypes) || isSpyCall(resultExpr) {
 							continue
 						}
 
-						// [핵심 수정] 제네릭 타입을 명시적으로 생성합니다.
-						// 예: lx.Spy(...) -> lx.Spy[float64](...)
-
-						// 1. lx.Spy 선택자 생성
 						spySelector := &ast.SelectorExpr{
 							X:   ast.NewIdent("lx"),
 							Sel: ast.NewIdent("Spy"),
 						}
 
-						// 2. 제네릭 인스턴스화 표현식 생성 (IndexExpr 사용)
-						// lx.Spy[Type] 형태를 만듭니다.
 						spyInstance := &ast.IndexExpr{
 							X:     spySelector,
-							Index: returnTypes[i], // 미리 추출해둔 타입 사용
+							Index: returnTypes[i],
 						}
 
-						// 3. 함수 호출 표현식 생성
 						spyCall := &ast.CallExpr{
-							Fun: spyInstance, // 명시된 제네릭 함수 사용
+							Fun: spyInstance,
 							Args: []ast.Expr{
 								&ast.BasicLit{
 									Kind:  token.STRING,
@@ -360,7 +347,6 @@ func runAndCapture(opts options, rootDir string) ([]TraceData, error) {
 		return nil, err
 	}
 
-	// 1. 프로젝트 내의 실행 가능한 모든 진입점(package main이 있는 디렉토리)을 찾습니다.
 	entryPoints, err := findMainPackages(absRoot)
 	if err != nil {
 		return nil, fmt.Errorf("failed to scan for main packages: %w", err)
@@ -378,9 +364,8 @@ func runAndCapture(opts options, rootDir string) ([]TraceData, error) {
 	var allTraces []TraceData
 	var executionErrors []string
 
-	// 2. 발견된 모든 진입점에 대해 각각 실행합니다.
 	for _, dir := range entryPoints {
-		// 상대 경로로 변환하여 로그 가독성 향상
+
 		relDir, _ := filepath.Rel(absRoot, dir)
 		if relDir == "" {
 			relDir = "."
@@ -389,8 +374,7 @@ func runAndCapture(opts options, rootDir string) ([]TraceData, error) {
 
 		traces, err := executeSinglePackage(ctx, goExe, dir, opts)
 		if err != nil {
-			// 특정 패키지 실행 실패가 전체 프로세스를 중단시키지 않도록 경고만 하고 넘어갈지 결정해야 합니다.
-			// 여기서는 에러를 기록하고 계속 진행합니다.
+
 			executionErrors = append(executionErrors, fmt.Sprintf("%s: %v", relDir, err))
 			continue
 		}
@@ -399,7 +383,7 @@ func runAndCapture(opts options, rootDir string) ([]TraceData, error) {
 
 	if len(executionErrors) > 0 {
 		errMsg := strings.Join(executionErrors, "\n\t- ")
-		// 경고(Warning)가 아니라 에러(Error)를 반환하여 main에서 잡게 합니다.
+
 		return allTraces, fmt.Errorf("execution failed in:\n\t- %s", errMsg)
 	}
 
@@ -450,7 +434,7 @@ func executeSinglePackage(ctx context.Context, goExe, dir string, opts options)
 			var td TraceData
 			if err := json.Unmarshal([]byte(payload), &td); err == nil {
 				td.Function = normalizeFuncName(td.Function)
-				// 파일 경로는 절대 경로로 저장되어야 나중에 매칭하기 쉽습니다.
+
 				if !filepath.IsAbs(td.File) {
 					td.File = filepath.Join(dir, td.File)
 				}
@@ -473,7 +457,6 @@ func executeSinglePackage(ctx context.Context, goExe, dir string, opts options)
 		waitErr = scanErr
 	}
 
-	// 컨텍스트 타임아웃 체크
 	if ctx.Err() == context.DeadlineExceeded {
 		return traces, fmt.Errorf("timeout")
 	}
@@ -503,16 +486,15 @@ func findMainPackages(root string) ([]string, error) {
 
 		dir := filepath.Dir(path)
 		if _, ok := seen[dir]; ok {
-			// 이미 이 디렉토리는 package main임을 확인했으므로 스킵
+
 			return nil
 		}
 
-		// 파일 내용을 파싱하여 패키지 이름 확인
 		fset := token.NewFileSet()
-		// PackageClauseOnly 옵션으로 빠르게 패키지명만 파싱
+
 		f, err := parser.ParseFile(fset, path, nil, parser.ParseComments|parser.PackageClauseOnly)
 		if err != nil {
-			return nil // 파싱 에러 무시
+			return nil
 		}
 
 		if f.Name.Name == "main" {
@@ -768,7 +750,6 @@ func processSingleTarget(opts options, llm LLM, cfg *Config, target TargetInfo)
 		}
 	}
 
-	// 4. 시스템 프롬프트 강화 (규칙 추가)
 	systemPrompt := fmt.Sprintf(`GO FUNC BODY GEN.
 
 SIG: %s
@@ -862,7 +843,6 @@ func newLLM(cfg *Config) (LLM, error) {
 		return nil, errors.New("nil config")
 	}
 
-	// Model은 공통 필수
 	if strings.TrimSpace(cfg.Model) == "" {
 		return nil, errors.New("empty model")
 	}
@@ -874,7 +854,6 @@ func newLLM(cfg *Config) (LLM, error) {
 
 	switch provider {
 	case "gemini":
-		// 기존 구글 API 방식
 		if strings.TrimSpace(cfg.ApiKey) == "" {
 			return nil, errors.New("empty api_key")
 		}
@@ -887,12 +866,15 @@ func newLLM(cfg *Config) (LLM, error) {
 		}
 		return &geminiLLM{client: client}, nil
 
-	case "command", "gemini-cli":
-		// [수정 2] 새로운 커맨드 방식 추가
+	case "command":
 		if strings.TrimSpace(cfg.BinPath) == "" {
 			return nil, errors.New("empty bin_path (required for command provider)")
 		}
-		return &commandLLM{binPath: cfg.BinPath}, nil
+
+		return &commandLLM{
+			binPath: cfg.BinPath,
+			args:    cfg.Args,
+		}, nil
 
 	default:
 		return nil, fmt.Errorf("unsupported provider: %s", cfg.Provider)
@@ -908,17 +890,27 @@ func (g *geminiLLM) Generate(ctx context.Context, model string, prompt string) (
 }
 
 func (c *commandLLM) Generate(ctx context.Context, model string, prompt string) (string, error) {
-	args := []string{"-p", prompt, "-m", model, "-o", "text"}
+	var finalArgs []string
+
+	if len(c.args) == 0 {
+		finalArgs = []string{"-p", prompt, "-m", model, "-o", "text"}
+	} else {
+		for _, arg := range c.args {
+			replaced := strings.ReplaceAll(arg, "{{prompt}}", prompt)
+			replaced = strings.ReplaceAll(replaced, "{{model}}", model)
+			finalArgs = append(finalArgs, replaced)
+		}
+	}
 
-	cmd := exec.CommandContext(ctx, c.binPath, args...)
+	cmd := exec.CommandContext(ctx, c.binPath, finalArgs...)
 
 	var out bytes.Buffer
 	var stderr bytes.Buffer
 	cmd.Stdout = &out
 	cmd.Stderr = &stderr
 
 	if err := cmd.Run(); err != nil {
-		return "", fmt.Errorf("gemini-cli failed: %v\nStderr: %s", err, stderr.String())
+		return "", fmt.Errorf("command execution failed: %v\nStderr: %s", err, stderr.String())
 	}
 
 	return out.String(), nil
@@ -991,7 +983,6 @@ func loadConfig() (*Config, string, error) {
 }
 
 func cleanAICode(code string) string {
-	// 1. 마크다운(```) 제거
 	if start := strings.Index(code, "```"); start != -1 {
 		if firstNL := strings.Index(code[start:], "\n"); firstNL != -1 {
 			content := code[start+firstNL+1:]
@@ -1001,7 +992,6 @@ func cleanAICode(code string) string {
 		}
 	}
 
-	// 2. 함수 시그니처(func ... { ) 제거
 	if strings.Contains(code, "func ") && strings.Contains(code, "{") {
 		if open := strings.Index(code, "{"); open != -1 {
 			if close := strings.LastIndex(code, "}"); close != -1 {
@@ -1010,26 +1000,18 @@ func cleanAICode(code string) string {
 		}
 	}
 
-	// [핵심 수정] 3. 덩그러니 남은 외곽 중괄호({ ... }) 제거
-	// AI가 코드 블록만 덜렁 줄 때가 있는데, 이걸 벗겨야 이중 중괄호가 안 생깁니다.
 	trimmed := strings.TrimSpace(code)
 	if strings.HasPrefix(trimmed, "{") && strings.HasSuffix(trimmed, "}") {
-		// 앞뒤 중괄호를 제거합니다.
 		code = trimmed[1 : len(trimmed)-1]
 	}
 
-	// 4. 줄 단위로 쪼개서 불필요한 공백 및 lx.Gen 호출 제거
 	lines := strings.Split(code, "\n")
 	var finalLines []string
 	for _, line := range lines {
 		t := strings.TrimSpace(line)
-		// 빈 줄이거나 lx.Gen 호출이면 무시
 		if t == "" || strings.Contains(t, "lx.Gen(") {
 			continue
 		}
-		// 원본 라인의 들여쓰기는 유지하는 것이 좋지만,
-		// 외곽 중괄호를 벗긴 경우 들여쓰기가 과도할 수 있으므로 TrimSpace를 하거나
-		// 여기서는 안전하게 내용만 가져갑니다. gofmt가 어차피 정리해줍니다.
 		finalLines = append(finalLines, line)
 	}
 
