package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/urfave/cli/v2"
)

func main() {
	app := &cli.App{
		Name:  "Boom",
		Usage: "repeat what you said",
		Action: func(ctx *cli.Context) error {
			arg := ctx.Args().Get(0)
			fmt.Printf("You said %q\n", arg)
			return nil
		},
	}
	if err := app.RunContext(ctx, os.Args); err != nil {
		log.Fatalln(err)
	}
}

go build -o repeat

 % ./repeat Good night
You said "Good"

./
├── LICENSE
├── README.md
├── cmd/
│   ├── eval.go
│   └── refactor.go
├── go.mod
├── go.sum
├── internal/
│   ├── application/
│   │   ├── api_interface.go
│   │   ├── evaluation/
│   │   │   └── evaluate.go
│   │   ├── presenter_interface.go
│   │   └── refactoring/
│   │       └── refactoring.go
│   ├── gateway/
│   │   └── api/
│   │       └── gemini_client.go
│   └── presenter/
│       ├── eval_presenter.go
│       ├── progress/
│       │   └── progress_bar.go
│       └── refactor_presenter.go
├── main.go
└── pkg/

func main() {
	if err := cmd.Execute(context.Background()); err != nil {
		fmt.Fprintf(os.Stderr, "Error : %v\n", err)
	}
}

const (
	version = "v1.0"
)

func Execute(ctx context.Context) error {
	evalCmd := newEvalCmd(evaluation.NewEvaluation())
	// refactorCmd:=newRefactorCmd(refactoring.NewRefactoring())
	app := &cli.App{
		Name:        "refacgo",
		Version:     version,
		Description: "A Go-based command-line tool that evaluates the code in a specified Go file and provides refactoring suggestions powered by AI",
		Commands: []*cli.Command{
			evalCmd.add(),
			// refactorCmd.add()
		},
	}
	if err := app.RunContext(context.Background(), os.Args); err != nil {
		return err
	}
	return nil
}

type evalCmd struct {
	Evalueation *evaluation.Evaluation
	// EvalPresenter *presenter.EvalPresenter
}

func newEvalCmd(evaluation *evaluation.Evaluation) *evalCmd {
	return &evalCmd{
		Evalueation: evaluation,
	}
}

func (cmd *evalCmd) add() *cli.Command {
	return &cli.Command{
		Name:        "evaluate",
		Aliases:     []string{"eval"},
		Description: "Evaluate code in the specifield file",
		Usage:       "Evaluate code in the specifield file",
		UsageText:   "refacgo eval [option] <filepath>",
		HelpName:    "eval",
		ArgsUsage:   "<filepath> is a path relative to the current directory where the command will be executed",
		Flags: []cli.Flag{
			&cli.BoolFlag{
				Name:    "japanese",
				Aliases: []string{"j"},
			},
			&cli.StringFlag{
				Name:    "description",
				Aliases: []string{"desc"},
				Value:   "",
				Usage:   "description of code in the specified file",
			},
		},
        // 適当
		Action: func(ctx *cli.Context) error {
			fmt.Println("Evaluate your code !!")
			return nil
		},
	}
}

 $ ./refacgo

NAME:
   refacgo - A new cli application

USAGE:
   refacgo [global options] command [command options]

VERSION:
   v1.0

DESCRIPTION:
   A Go-based command-line tool that evaluates the code in a specified Go file and provides refactoring suggestions powered by AI

COMMANDS:
   evaluate, eval  Evaluate code in the specifield file
   help, h         Shows a list of commands or help for one command

GLOBAL OPTIONS:
   --help, -h     show help
   --version, -v  print the version

$ ./refacgo eval

Evaluate your code !!

func LoadFile(filepath string) ([]byte, error) {
	f, err := os.Open(filepath)
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	var buf bytes.Buffer
	// ファイルを読み込む
	scannar := bufio.NewScanner(f)
	// 一行ごとにループ
	for scannar.Scan() {
		// bufに書き込み
		buf.Write(scannar.Bytes())
		// 文末に改行
		buf.WriteByte('\n') //1バイト書き込む
	}
	return buf.Bytes(), nil
}

func TestLoadFile(t *testing.T) {
	t.Parallel()
	tests := []struct {
		name     string
		filepath string
		want     []byte
		wantErr  bool
	}{
		{
			name:     "ファイルを読み込み、正しいバイトスライスを返す",
			filepath: "./testdata/sample.txt",
			want:     []byte("This is Sample File.\n"),
			wantErr:  false,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			got, err := LoadFile(tt.filepath)
			if (err != nil) != tt.wantErr {
				t.Errorf("utils.LoadFile() error = %v ,wantErr = %v", err, tt.wantErr)
			}
			if diff := cmp.Diff(got, tt.want); diff != "" {
				t.Errorf("loadFile return byte mismatch(-want +got):\n%s", diff)
			}
		})
	}
}

  func (cmd *evalCmd) run(ctx *cli.Context) error {
	// 引数のファイルを読み込む
	b, err := utils.LoadFile(ctx.Args().Get(0))
	if err != nil {
		return err
	}
  // 以降、処理の続きを書いていく...
}

type Evaluate interface {
    Evaluate(ctx context.Context, src []byte) ([]byte, error)
}

//具体実装
type EvaluateByGemini struct {
    // geminiクライアント
}

func NewEvaluateByGemini() *EvaluateByGemini {
    return &EvaluateByGemini{
        // gemini: gemini,
    }
}

// インターフェースを満たすメソッドを定義
func (ev *EvaluateByGemini) Evaluate(ctx context.Context, src []byte) ([]byte, error) {

}

type EvalPrinter struct {
    //  プログレスバー
}

func NewEvalPrinter() *EvalPrinter {
    return &EvalPrinter{}
}

func (ep *EvalPrinter) EvalPrint(ctx context.Context, evalb []byte) error {
    return nil
}

func (cmd *evalCmd) run(cCtx *cli.Context) error {
	// 引数のファイルを読み込んで、バイトスライスを格納
	src, err := loadfile.LoadFile(cCtx.Args().Get(0))
	if err != nil {
		return err
	}
	// 読み取ったソースファイルを評価する
	evalb, err := cmd.Evalueation.Evaluate(cCtx.Context, src)
	if err != nil {
		return err
	}
	// 評価コメントをプレゼンターに渡して出力
	if err := cmd.EvalPresenter.EvalPrint(cCtx.Context, evalb); err != nil {
		return err
	}
	return nil
}

func Execute(ctx context.Context) error {
	evalCmd := newEvalCmd(evaluation.NewEvaluateByGemini(), presenter.NewEvalPrinter())
	app := &cli.App{
		Name:        "refacgo",
		Version:     version,
		Description: "A Go-based command-line tool that evaluates the code in a specified Go file and provides refactoring suggestions powered by AI",
		Commands: []*cli.Command{
			evalCmd.add(),
		},
	}
	if err := app.RunContext(ctx, os.Args); err != nil {
		return err
	}
	return nil
}

const (
	geminiModel = "gemini-1.5-flash"
)

type GeminiClient struct {
	geminiConfig config.GeminiConfig
	client       *genai.Client
	model        *genai.GenerativeModel
}

func NewGeminiClient(geminiConfig config.GeminiConfig, ctx context.Context) *GeminiClient {
	client, err := genai.NewClient(ctx)
	defer client.Close()
	model := client.GenerativeModel(geminiModel)
	if err != nil {
		log.Fatal(err)
	}
	return &GeminiClient{
		geminiConfig: geminiConfig,
		client:       client,
		model:        model,
	}
}

func (gc *GeminiClient) GenerateText(ctx context.Context, src []byte) ([]byte, error) {
	// 実行が終わったらクライアントをクローズしておく
	defer gc.client.Close()
	// 受け取ったバイト配列を文字列にしたものをラップ
	text := genai.Text(string(src))
	resp, err := gc.model.GenerateContent(ctx, text)
	if err != nil {
		return nil, err
	}
	// respをどうしよう？？
}

type GenerateContentResponse struct {
	// Candidate responses from the model.
	Candidates []*Candidate
	// Returns the prompt's feedback related to the content filters.
	PromptFeedback *PromptFeedback
	// Output only. Metadata on the generation requests' token usage.
	UsageMetadata *UsageMetadata
}

// Candidate is a response candidate generated from the model.
type Candidate struct {
	// Output only. Index of the candidate in the list of candidates.
	Index int32
	// Output only. Generated content returned from the model.
	Content *Content
	// Optional. Output only. The reason why the model stopped generating tokens.
	//
	// If empty, the model has not stopped generating the tokens.
	FinishReason FinishReason
	// List of ratings for the safety of a response candidate.
	//
	// There is at most one rating per category.
	SafetyRatings []*SafetyRating
	// Output only. Citation information for model-generated candidate.
	//
	// This field may be populated with recitation information for any text
	// included in the `content`. These are passages that are "recited" from
	// copyrighted material in the foundational LLM's training data.
	CitationMetadata *CitationMetadata
	// Output only. Token count for this candidate.
	TokenCount int32
}

type Content struct {
	// Ordered `Parts` that constitute a single message. Parts may have different
	// MIME types.
	Parts []Part
	// Optional. The producer of the content. Must be either 'user' or 'model'.
	//
	// Useful to set for multi-turn conversations, otherwise can be left blank
	// or unset.
	Role string
}

// A Part is a piece of model content.
// A Part can be one of the following types:
//   - Text
//   - Blob
//   - FunctionCall
//   - FunctionResponse
//   - ExecutableCode
//   - CodeExecutionResult
type Part interface {
	toPart() *pb.Part
}

type Text string

func (t Text) toPart() *pb.Part {
	return &pb.Part{
		Data: &pb.Part_Text{Text: string(t)},
	}
}

func (gc *GeminiClient) GenerateText(ctx context.Context, src []byte, prompt string) (string, error) {
	// client&modelが何らかの理由でnilの場合は早期リターン
	if gc.client == nil || gc.model == nil {
		return "", errors.New("connection to gemini failed")
	}
	// 実行が終わったらクライアントをクローズしておく
	defer gc.client.Close()
	// 受け取ったバイト配列を文字列にしたものをラップ
	code := genai.Text(string(src))
	// プロンプトをラップ
	promptText := genai.Text(prompt)
	resp, err := gc.model.GenerateContent(ctx, code, promptText)
	if err != nil {
		return "", err
	}
	var respString string
	for _, cand := range resp.Candidates {
		if cand.Content == nil {
			continue
		}
		for _, part := range cand.Content.Parts {
			// Text型の場合のみレスポンス文字列に格納する
			switch p := part.(type) {
			case genai.Text:
				respString = string(p)
			}
		}
	}
	return respString, nil
}

type EvalPrinter struct {
	//  プログレスバー
}

func NewEvalPrinter() *EvalPrinter {
	return &EvalPrinter{}
}

func (ep *EvalPrinter) EvalPrint(ctx context.Context, text string) error {
	fmt.Println(text)
	return nil
}

$  refacgo eval -j  ./pkg/load_file/load_file.go

## Code Evaluation: `loadfile.go`

**Readability:** ⭐️⭐️⭐️⭐️⭐️ (5/10)

* **Good:**  Variable names (`filepath`, `buf`, `scannar`) are descriptive and understandable.
* **Good:** Comments explain the purpose of each section and specific actions (like adding a newline).
* **Room for Improvement:**  The logic could be slightly improved by using `ioutil.ReadFile` instead of manual scanning for better readability and conciseness.

**Maintainability:** ⭐️⭐️⭐️⭐️ (4/10)

* **Good:** The function is self-contained and performs a single, well-defined task.
* **Room for Improvement:** The code is not very flexible. It assumes a single file path.  Consider making it more flexible by allowing multiple paths or using a Reader interface for greater versatility.

**Performance:** ⭐️⭐️⭐️⭐️ (4/10)

* **Good:**  The code is efficient for reading small files. 
* **Room for Improvement:**  For large files, `ioutil.ReadFile` would be more performant as it uses buffered I/O internally.  The `for` loop with manual newline additions might become a bottleneck with large files.

**Error Handling:** ⭐️⭐️⭐️⭐️⭐️ (5/10)

* **Good:** The function handles errors gracefully by returning an error value and using `log.Fatal` if an error occurs while opening the file.
* **Room for Improvement:**  `log.Fatal` should generally be avoided in library code.  Instead, return the error to the caller for more control.

**Testability:** ⭐️⭐️⭐️⭐️ (4/10)

* **Good:** The function is simple enough to test. 
* **Room for Improvement:** Consider using a `testing.T` argument to the function for more comprehensive testing and use `t.Fatal` for test failures instead of `log.Fatal`.

**Security:** ⭐️⭐️ (2/10)

* **Major Room for Improvement:**  There is no input validation.  The code blindly accepts a file path.  This makes it vulnerable to path traversal attacks.  Use `filepath.Clean` and sanitize input to prevent these vulnerabilities.

**Documentation:** ⭐️⭐️⭐️ (3/10)

* **Good:** The function has a basic docstring explaining its purpose.
* **Room for Improvement:**  Provide more detailed documentation for the function, including its arguments, return values, error cases, and potential usage examples.

**Reusability:** ⭐️⭐️⭐️ (3/10)

* **Good:** The function can be reused in other projects, but it's tightly coupled to file paths.
* **Room for Improvement:**  Consider abstracting the function to use a `Reader` interface for more generic use cases and broader reusability.

**Consistency:** ⭐️⭐️⭐️ (3/10)

* **Good:** The coding style is generally consistent. 
* **Room for Improvement:**  Consider following established Go style guides for consistent indentation and naming conventions (e.g., camelCase for variables and function names).

**Selection of Appropriate Algorithms:** ⭐️⭐️⭐️ (3/10)

* **Good:**  The code uses appropriate algorithms for reading a file. 
* **Room for Improvement:**  For large files, consider using more optimized methods like `ioutil.ReadFile` to reduce memory overhead and improve performance.

**Total Score:** ⭐️⭐️⭐️⭐️ (40/100)

**Advice:**

* **Simplify and improve performance:** Use `ioutil.ReadFile` for reading files, especially for larger files.
* **Improve Security:**  Validate and sanitize file paths to prevent vulnerabilities.
* **Enhance Reusability:** Abstract the function to use a `Reader` interface.
* **Improve Documentation:**  Provide detailed documentation for the function, including arguments, return values, error cases, and potential usage examples.
* **Improve Error Handling:** Avoid `log.Fatal` in library code and return errors to the caller.
* **Consider Testing:** Write unit tests for the function.

This code demonstrates a basic understanding of reading files in Go.  However, it needs improvement in terms of performance, security, reusability, and documentation.  By addressing these areas, the code will be more robust, maintainable, and efficient. 

$ refacgo eval -j  ./cmd/eval/eval.go 

## コードレビュー: ./cmd/eval/eval.go

**可読性 (Readability): 9/10** 

* 👍 関数名 `EvalCmd` と `initEvalCmdAction` は明確で理解しやすいです。
* 👍 変数名 `cCtx` は文脈から理解できますが、 `ctx` の方が一般的かもしれません。
* 👍 コメントは簡潔で分かりやすく、コードの意図を説明しています。

**保守性 (Maintainability): 8/10**

* 👍 コードはモジュール化され、 `EvalCmd` 関数は `initEvalCmdAction` 関数を呼び出すことで、処理を分離しています。
* 👍  `config.Config` をパラメータとして受け取ることで、外部との依存性を減らし、テストしやすくなっています。
* 🤔 `initEvalCmdAction` 関数の内部処理の詳細が不明なため、将来の修正や拡張が少し難しくなる可能性があります。

**パフォーマンス (Performance): 9/10**

* 👍 特にパフォーマンスに影響を与えるようなコードは含まれていません。
* 👍 必要最低限の処理のみ行っているため、実行効率は良好です。

**エラーハンドリング (Error Handling): 7/10**

* 👍 `evalCmdAction.run` で発生するエラーを適切に処理しています。
* 🤔  `evalCmdAction.run` の内部で発生するエラーの詳細が不明です。より詳細なエラーハンドリングが必要かもしれません。

**テスト可能性 (Testability): 7/10**

* 👍 `config.Config` をパラメータとして受け取っているため、モックオブジェクトを使ってテストすることができます。
* 🤔 `initEvalCmdAction` 関数の内部処理の詳細が不明なため、ユニットテストが書きにくい可能性があります。

**セキュリティ (Security): 8/10**

* 👍 特にセキュリティ上の問題は見当たりません。
* 🤔 入力値の検証やサニタイズ処理は行われていません。セキュリティを考慮した設計が必要かもしれません。

**ドキュメント (Documentation): 7/10**

* 👍  `cli.Command` の `Description` と `UsageText` に機能の説明と使用方法が記載されています。
* 🤔 `initEvalCmdAction` 関数などの内部処理の詳細なドキュメントがありません。

**再利用性 (Reusability): 8/10**

* 👍  `EvalCmd` 関数は、他のプロジェクトでも再利用可能な汎用的なコードです。
* 👍  `config.Config` をパラメータとして受け取っているため、様々な環境で利用できます。

**一貫性 (Consistency): 9/10**

* 👍 コーディングスタイルは一貫しており、読みやすいです。

**適切なアルゴリズムの選定 (Selection of appropriate algorithms): N/A**

* 該当なし

**総合評価: 78/100**

**アドバイス:**

* 👍  `initEvalCmdAction` 関数の内部処理を明確化し、ドキュメントを追加することで、保守性とテスト可能性を向上させることができます。
* 🤔  エラーハンドリングの詳細を検討し、より詳細なエラーメッセージを提供できるように改善してください。
* 🤔  入力値の検証とサニタイズ処理を導入することで、セキュリティを向上させることができます。

**コメント:**

全体的には可読性が高く、保守性も良好なコードです。 
いくつかの改善点がありますが、基本的な設計はしっかりしており、良いコードと言えるでしょう。 
特に `initEvalCmdAction` 関数の内部処理の詳細を公開することで、より優れたコードになります。

// ビジネスロジックコンポーネントの振る舞い
type Evaluation interface {
	Evaluate(ctx context.Context, src []byte, filename string, ch chan<- string) error
}

//生成AIコンポーネントの振る舞い
type GenAI interface {
	Query(ctx context.Context, src []byte, prompt string, ch chan<- string) error
}

//プレゼンターの振る舞い
type EvalPresenter interface {
	EvalPrint(ctx context.Context, ch <-chan string) error
}

func (eca *evalCmdAction) run(cCtx *cli.Context, ctx context.Context) error {
	if cCtx.NArg() != 1 {
		return errors.New("only one argument, the filename, is required")
	}
	// ファイル名（パス）を引数から取得
	filename := cCtx.Args().Get(0)
	// 引数のファイルを読み込んで、バイトスライスを格納
	src, err := loadfile.LoadFile(filename)
	if err != nil {
		return err
	}
	// descフラグから文字列を取得し、ソースに追加
	desc := cCtx.String("description")
	// フラグから""が帰ってきた時はそのままソースはそのまま返る
	src = utils.AddDescToSrc(src, desc)
	// Evaluateの結果をモジュール間で逐次出力するためのチャネル
	ch := make(chan string)
	// ビジネスロジック
	// 結果をストリームでチャネルに送信する
	err = eca.Evalueation.Evaluate(ctx, src, filename, ch)
	if err != nil {
		return err
	}
	// チャネルからストリームで受信する
	if err := eca.EvalPresenter.EvalPrint(ctx, ch); err != nil {
		return err
	}
	return nil
}

func (ev *EvaluationWithGenAI) Evaluate(ctx context.Context, src []byte, filename string, ch chan<- string) error {
	path := filepath.Join("internal", "application", "evaluation", "genai_instruction.txt")
	instruction, err := loadfile.LoadFile(path)
	if err != nil {
		panic(err)
	}
	prompt := fmt.Sprintf("The name of this file is %q.\n\n%v\n\n", filename, string(instruction))
    //受信チャネルを渡す
	err = ev.genAI.Query(ctx, src, prompt, ch)
	if err != nil {
		return err
	}
	return nil
}

unc (gc *Gemini) Query(ctx context.Context, src []byte, prompt string, ch chan<- string) error {
	// client & modelが何らかの理由でnilの場合は早期リターン
	if gc.client == nil || gc.model == nil {
		return errors.New("connection to Gemini failed")
	}
	// 実行が終わったらクライアントをクローズしておく
	defer func() error {
		if err := gc.client.Close(); err != nil {
			return err
		}
		return nil
	}()

	// 受け取ったバイト配列を文字列にしたものをラップ
	code := genai.Text(string(src))
	// プロンプトをラップ
	promptText := genai.Text(prompt)
	// ストリーミングで逐次的に文字列を受け取れるようにする
	iter := gc.model.GenerateContentStream(ctx, code, promptText)
	//レスポンス文字列を送信するチャネル
	go func() error {
		defer close(ch)

		for {
			// ストリーミング
			resp, err := iter.Next()
			if err == iterator.Done {
				break
			}
			if err != nil {
				return err
			}
			// レスポンスを文字列にキャストしてチャネルに送信
			for _, cand := range resp.Candidates {
				if cand.Content == nil {
					continue
				}
				for _, part := range cand.Content.Parts {
					// Text型の場合のみレスポンス文字列に格納する
					switch p := part.(type) {
					case genai.Text:
						ch <- string(p)
					}
				}
			}
		}
		return nil
	}()

	return nil
}

func (ep *EvalPrinter) EvalPrint(ctx context.Context, ch <-chan string) error {
	is := ep.indicater.Spinner
	is.Suffix = "  Waiting for evaluating..."
	is.Start()
	defer is.Stop() // 処理の最後に必ずスピナーを停止する

	for {
		select {
		case <-ctx.Done():
			return ctx.Err() // キャンセル通知がされた場合
		case text, ok := <-ch:
			if !ok {
				return nil // チャネルが閉じられた場合
			}
			if is.Active() {
				time.Sleep(2 * time.Second)
				is.Stop()
			}
			fmt.Println(text)
		}
	}
}

func (ev *EvaluationWithGenAiInJap) Evaluate(ctx context.Context, src []byte, filename string, ch chan<- string) error {
	path := filepath.Join("internal", "application", "evaluation", "instruction_text", "genai_instruction_in_jap.txt")
	instruction, err := loadfile.LoadFile(path)
	if err != nil {
		panic(err)
	}
	prompt := fmt.Sprintf("このファイルの名前は%qです。\n\n%v\n\n", filename, string(instruction))
	go func() error {
		defer close(ch)
		err = ev.genAI.Query(ctx, src, prompt, ch)
		if err != nil {
			return err
		}
		return nil
	}()
	return nil
}

func (eca *evalCmdAction) run(cCtx *cli.Context, ctx context.Context) error {

    // 省略

    //Evaluate内のQueryが非同期に移行するので、すぐにこの下のEvalPrinterに処理が移る
	err = eca.Evalueation.Evaluate(ctx, src, filename, ch)　
	if err != nil {
		return err
	}
	// すぐに処理が移るので、すぎにインジケータスピナーも実行される
	if err := eca.EvalPresenter.EvalPrint(ctx, ch); err != nil {
		return err
	}
	return nil
}

func LoadFile(filepath string) ([]byte, error) {
	f, err := os.Open(filepath)
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	var buf bytes.Buffer
	// ファイルを読み込む
	scannar := bufio.NewScanner(f)
	// 一行ごとにループ
	for scannar.Scan() {
		// bufに書き込み
		buf.Write(scannar.Bytes())
		// 文末に改行
		buf.WriteByte('\n') //1バイト書き込む
	}
	return buf.Bytes(), nil
}

// アプリケーション内で利用する内部リソースを読み込む関数
func LoadInternal(relativePath string) ([]byte, error) {
	// 呼び出しもとのパスを得る
	_, caller_path, _, ok := runtime.Caller(1)
	if !ok {
		return nil, fmt.Errorf("failed to get caller information")
	}
	basePath := filepath.Dir(caller_path)
	absPath := filepath.Join(basePath, relativePath)
	f, err := os.Open(absPath)
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	// バッファを持った空のバイト配列
	var buf bytes.Buffer
	// 行単位でファイルを読み込む
	scannar := bufio.NewScanner(f)
	// 一行ごとにループ
	for scannar.Scan() {
		// bufに書き込み
		buf.Write(scannar.Bytes())
		// 文末に改行
		buf.WriteByte('\n') //1バイト書き込む
	}
	return buf.Bytes(), nil
}

//　ワーキングディレクトリからの相対パスを指定すると、
MacBook-Air refacgo % refacgo eval  ./cmd/eval/eval_cmd_action.go
// LoadFileを呼び出した階層+相対パスを探してしまう
2024/11/15 01:53:36 open /Users/xxxxxxx/my_portfolio/refacgo/cmd/eval/cmd/eval/eval_cmd_action.go: no such file or directory

// アプリケーション内で利用する内部リソースを読み込む関数
func LoadInternal(relativePath string) ([]byte, error) {
	// 呼び出しもとのパスを得る
	_, caller_path, _, ok := runtime.Caller(1)
	if !ok {
		return nil, fmt.Errorf("failed to get caller information")
	}
	basePath := filepath.Dir(caller_path)
	absPath := filepath.Join(basePath, relativePath)
	f, err := os.Open(absPath)
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	// バッファを持った空のバイト配列
	var buf bytes.Buffer
	// 行単位でファイルを読み込む
	scannar := bufio.NewScanner(f)
	// 一行ごとにループ
	for scannar.Scan() {
		// bufに書き込み
		buf.Write(scannar.Bytes())
		// 文末に改行
		buf.WriteByte('\n') //1バイト書き込む
	}
	return buf.Bytes(), nil
}

// コマンドラインの入力から受け取ったファイルパスからファイルを読み込むための関数
func LoadExternal(filename string) ([]byte, error) {
	f, err := os.Open(filename)
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	var buf bytes.Buffer
	// ファイルを読み込む
	scannar := bufio.NewScanner(f)
	// 一行ごとにループ
	for scannar.Scan() {
		// bufに書き込み
		buf.Write(scannar.Bytes())
		// 文末に改行
		buf.WriteByte('\n') //1バイト書き込む
	}
	return buf.Bytes(), nil
}

// 呼び出しもとのパスを得る
	_, caller_path, _, ok := runtime.Caller(1)

func TestEvauationWithGenAI(t *testing.T) {
	t.Parallel()
	ctrl := gomock.NewController(t)
	mockGenAI := application.NewMockGenAI(ctrl)
	srcArg := []byte("This is sample code.")
	respString := []string{"This is comments of evalutated code!!!", "This is response from Mock!!!"}
	type args struct {
		src      []byte
		filename string
	}
	tests := []struct {
		name     string
		mockFunc func()
		args     args
		wantErr  bool
		want     string
	}{
		{
			name: "GenAIにソースコード・プロンプトを正常に渡し、非同期的にチャネルに文字列を送信できる",
			mockFunc: func() {
				mockGenAI.EXPECT().Query(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Do(
					func(ctx context.Context, src []byte, prompt string, ch chan<- string) {
						// 正確にプロンプト・ソースコードをQueryに渡しているか
						expectedPrompt, err := loadfile.LoadInternal("./testdata/prompt/with_genai_prompt.txt")
						if err != nil {
							t.Error(err)
						}
						if diff := cmp.Diff(string(expectedPrompt), prompt); diff != "" {
							t.Errorf("prompt received from EvaluationWithGenAI mismatch (-want +got):\n%s", diff)
						}
						if diff := cmp.Diff(srcArg, src); diff != "" {
							t.Errorf("src received from  mismatch EvaluationWithGenAI mismatch (-want +got):\n%s", diff)
						}
						defer close(ch)
						// 文字列をチャネルに送信
						for _, rs := range respString {
							ch <- rs
						}
					},
				)
			},
			args: args{
				src:      srcArg,
				filename: "test.go",
			},
			want: respString[0] + respString[1],
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			tt.mockFunc()
			ctx := context.Background()
			evaluation := NewEvaluationWithGenAI(mockGenAI)
			ch := make(chan string)
			evaluation.Evaluate(ctx, tt.args.src, tt.args.filename, ch)
			// チャネルから文字列を受信
			var ss []string
			for text := range ch {
				ss = append(ss, text)
			}
			got := ss[0] + ss[1]
			if got != tt.want {
				t.Errorf("evaluated response not match,want: %q,got: %q", tt.want, got)
			}

		})
	}
}

func Execute(ctx context.Context, cfg *config.Config) error {
	app := &cli.App{
		Name:        "refacgo",
		Version:     version,
		Description: "A Go-based command-line tool that evaluates the code in a specified Go file and provides refactoring suggestions powered by AI",
		Commands: []*cli.Command{
			eval.EvalCmd(cfg, ctx),
		},
	}
	if err := app.RunContext(ctx, os.Args); err != nil {
		return err
	}
	return nil
}

func EvalCmd(cfg *config.Config, ctx context.Context) *cli.Command {
	return &cli.Command{
          //省略
		Action: func(cCtx *cli.Context) error {
			evalCmdAction := initEvalCmdAction(cCtx, cfg)
			if err := evalCmdAction.run(cCtx, ctx); err != nil {
				return err
			}
			return nil
		},
	}
}

// コマンドアクションを初期化する
// japaneseフラグがあれば、日本語対応のEvaluationをDIする
func initEvalCmdAction(cCtx *cli.Context, cfg *config.Config) *evalCmdAction {
	var evalCmdAction *evalCmdAction

	if cCtx.Bool("japanese") {
		evalCmdAction = newEvalCmdAction(
			evaluation.NewEvaluationWithGenAiInJap(
				gemini.NewGemini(cfg.GeminiConfig, cCtx.Context),
			),
			presenter.NewEvalPrinter(),
		)
	} else {
		evalCmdAction = newEvalCmdAction(
			evaluation.NewEvaluationWithGenAI(
				gemini.NewGemini(cfg.GeminiConfig, cCtx.Context),
			),
			presenter.NewEvalPrinter(),
		)
	}
	return evalCmdAction
}

func Execute(ctx context.Context, cfg *config.Config) error {
	// geminiを初期化
	gemini := gemini.NewGemini(cfg.GeminiConfig, ctx)
	app := &cli.App{
		Name:        "refacgo",
		Version:     version,
		Description: "A Go-based command-line tool that evaluates the code in a specified Go file and provides refactoring suggestions powered by AI",
		Commands: []*cli.Command{
			eval.EvalCmd(ctx, gemini, presenter.NewEvalPrinter()),
		},
	}
	if err := app.RunContext(ctx, os.Args); err != nil {
		return err
	}
	return nil
}

func TestEvalCmd(t *testing.T) {
	t.Parallel()

	ctrl := gomock.NewController(t)
	mockGenAI := application.NewMockGenAI(ctrl)
	mockEvalPresenter := evaluation.NewMockEvalPresenter(ctrl)
	srcArg := []byte("This is sample code.\n")
	respString := []string{"This is comments of evalutated code!!!", "This is response from Mock!!!"}
	respStringInJap := []string{"とてもいいコードです！！", "とてもいいテストコードです！！"}
	srcArgWithDesc := []byte("これはテストで用いるためのものです。 :\n\n\nThis is sample code.\n")
	// チャネルから受信した文字列を格納する配列
	var got []string
	tests := []struct {
		name     string
		args     []string
		mockFunc func()
		want     string
		wantErr  bool
	}{
		{
			name: "フラグなしでコマンドを叩くと評価コメントが返る",
			args: []string{"refacgo", "eval", "./testdata/src/sample.txt"},
			mockFunc: func() {
				mockGenAI.EXPECT().Query(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Do(
					func(ctx context.Context, src []byte, prompt string, ch chan<- string) {
						// 正確にプロンプト・ソースコードをQueryに渡しているか
						expectedPrompt, err := loadfile.LoadInternal("./testdata/prompt/eval/with_genai_prompt.txt")
						if err != nil {
							t.Error(err)
						}
						if diff := cmp.Diff(string(expectedPrompt), prompt); diff != "" {
							t.Errorf("prompt received from EvaluationWithGenAI mismatch (-want +got):\n%s", diff)
						}
						if diff := cmp.Diff(srcArg, src); diff != "" {
							t.Errorf("src received from  mismatch EvaluationWithGenAI mismatch (-want +got):\n%s", diff)
						}
						// 文字列をチャネルに送信
						for _, rs := range respString {
							ch <- rs
						}
						defer close(ch)
					},
				)
				mockEvalPresenter.EXPECT().EvalPrint(gomock.Any(), gomock.Any()).Do(
					func(ctx context.Context, ch <-chan string) {
						for text := range ch {
							got = append(got, text)
						}
					},
				)
			},
			want:    respString[0] + respString[1],
			wantErr: false,
		},
		{
			name: "-jフラグをつけてコマンドを叩くと日本語による評価コメントが返る",
			args: []string{"refacgo", "eval", "-j", "./testdata/src/sample.txt"},
			mockFunc: func() {
				mockGenAI.EXPECT().Query(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Do(
					func(ctx context.Context, src []byte, prompt string, ch chan<- string) {
						// 正確にプロンプト・ソースコードをQueryに渡しているか
						expectedPrompt, err := loadfile.LoadInternal("./testdata/prompt/eval/with_genai_in_jap_prompt.txt")
						if err != nil {
							t.Error(err)
						}
						if diff := cmp.Diff(string(expectedPrompt), prompt); diff != "" {
							t.Errorf("prompt received from EvaluationWithGenAI mismatch (-want +got):\n%s", diff)
						}
						if diff := cmp.Diff(src, src); diff != "" {
							t.Errorf("src received from  mismatch EvaluationWithGenAI mismatch (-want +got):\n%s", diff)
						}
						defer close(ch)
						// 文字列をチャネルに送信
						for _, rs := range respStringInJap {
							ch <- rs
						}
					},
				)
				mockEvalPresenter.EXPECT().EvalPrint(gomock.Any(), gomock.Any()).Do(
					func(ctx context.Context, ch <-chan string) {
						for text := range ch {
							got = append(got, text)
						}
					},
				)
			},
			want:    respStringInJap[0] + respStringInJap[1],
			wantErr: false,
		},
		{
			name: "-jフラグをつけ、-descフラグをつけてコマンドを叩くと日本語による評価コメントが返り、ソースコードに説明が追加される",
			args: []string{"refacgo", "eval", "-j", "-desc", "これはテストで用いるためのものです。", "./testdata/src/sample.txt"},
			mockFunc: func() {
				mockGenAI.EXPECT().Query(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Do(
					func(ctx context.Context, src []byte, prompt string, ch chan<- string) {
						// 正確にプロンプト・ソースコードをQueryに渡しているか
						expectedPrompt, err := loadfile.LoadInternal("./testdata/prompt/eval/with_genai_in_jap_prompt.txt")
						if err != nil {
							t.Error(err)
						}
						if diff := cmp.Diff(string(expectedPrompt), prompt); diff != "" {
							t.Errorf("prompt received from EvaluationWithGenAI mismatch (-want +got):\n%s", diff)
						}
						if diff := cmp.Diff(srcArgWithDesc, src); diff != "" {
							t.Errorf("src received from  mismatch EvaluationWithGenAI mismatch (-want +got):\n%s", diff)
						}
						defer close(ch)
						// 文字列をチャネルに送信
						for _, rs := range respStringInJap {
							ch <- rs
						}
					},
				)
				mockEvalPresenter.EXPECT().EvalPrint(gomock.Any(), gomock.Any()).Do(
					func(ctx context.Context, ch <-chan string) {
						for text := range ch {
							got = append(got, text)
						}
					},
				)
			},
			want:    respStringInJap[0] + respStringInJap[1],
			wantErr: false,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Cleanup(func() {
				got = []string{}
			})
			tt.mockFunc()
			ctx := context.Background()
			app := &cli.App{
				Name:        "refacgo",
				Description: "A Go-based command-line tool that evaluates the code in a specified Go file and provides refactoring suggestions powered by AI",
				Commands: []*cli.Command{
					EvalCmd(ctx, mockGenAI, mockEvalPresenter),
				},
			}
			if err := app.RunContext(ctx, tt.args); err != nil {
				t.Errorf("Error in Running CLI : %v", err)
			}
			if diff := cmp.Diff(tt.want, got[0]+got[1]); diff != "" {
				t.Errorf("expected output mismatch (-want +got):\n%s", diff)
			}
		})
	}
}

type Refactoring interface {
	Refactor(ctx context.Context, src []byte, filename string, ch chan<- string) ([]byte, error)
}

type Differ interface {
	Diff(originSrc, refactSrc string) string
}

type RefacPrinter interface {
	Print(text string)
}

type RefacOverWriter interface {
	OverWrite(w io.Writer, src string)
}

func Execute(ctx context.Context, cfg *config.Config) error {
	// geminiを初期化
	gemini := gemini.NewGemini(cfg.GeminiConfig, ctx)
	app := &cli.App{
		Name:        "refacgo",
		Version:     version,
		Description: "A Go-based command-line tool that evaluates the code in a specified Go file and provides refactoring suggestions powered by AI",
		Commands: []*cli.Command{
			eval.EvalCmd(ctx, gemini, presenter.NewEvalConsolePrinter()),
            // refacコマンドを追加
			refac.RefacCmd(ctx, gemini, diff.NewCmpDiffer(), presenter.NewRefacConsolePrinter(), presenter.NewRefacFileOverWriter()),
		},
	}
	if err := app.RunContext(ctx, os.Args); err != nil {
		return err
	}
	return nil
}

func RefacCmd(ctx context.Context, genAI application.GenAI, differ diff.Differ, refacPrinter refactoring.RefacPrinter, refacOverWiter refactoring.RefacOverWriter) *cli.Command {
	return &cli.Command{
		Name:        "refactor",
		Aliases:     []string{"refac"},
		Description: "refactor code in the specifield file",
		Usage:       "refactor code in the specifield file",
		UsageText:   "refacgo refac [option] <filepath>",
		HelpName:    "refac",
		ArgsUsage:   "<filepath> is a path relative to the current directory where the command will be executed",
		Flags: []cli.Flag{
			&cli.BoolFlag{
				Name:    "japanese",
				Aliases: []string{"j"},
			},
			&cli.StringFlag{
				Name:    "description",
				Aliases: []string{"desc"},
				Value:   "",
				Usage:   "description of code in the specified file",
			},
		},
		Action: func(cCtx *cli.Context) error {
			refacCmdAction := initRefacCmdAction(cCtx, genAI, differ, refacPrinter, refacOverWiter)
			if err := refacCmdAction.run(cCtx, ctx); err != nil {
				return err
			}
			return nil
		},
	}
}

func initRefacCmdAction(cCtx *cli.Context, genAI application.GenAI, differ diff.Differ, refacPrinter refactoring.RefacPrinter, refacOverWiter refactoring.RefacOverWriter) *refacCmdAction {
	var refacCmdAction *refacCmdAction

	// -jフラグによってRefacotringインスタンスを切り替える
	// ここでcmdActionを初期化する
	if cCtx.Bool("japanese") {
		// refacCmdAction = newRefacCmdAction(
		// 	refactoring.NewRefactoringWithGenAiInJap(
		// 		genAI,
		// 	),
		// 	diff.NewCmpDiffer(),
		// 	refacPrinter,
		// 	refacOverWiter,
		// )
	} else {
		refacCmdAction = newRefacCmdAction(
			refactoring.NewRefactoringWithGenAI(
				genAI,
			),
			differ,
			refacPrinter,
			refacOverWiter,
		)
	}
	return refacCmdAction
}

.
├── cli                              // CLIアプリケーションのエントリーポイントとコマンド
│   ├── eval                         // evalコマンド関連ファイル
│   │   ├── eval_cmd.go              // evalコマンドオブジェクト
│   │   ├── eval_cmd_action.go       // evalコマンドのアクション（ロジック）
│   │   ├── eval_test.go             // evalコマンドのテスト
│   │   └── testdata                 // evalコマンド用のテストデータ
│   │       ├── prompt               // プロンプト用テストデータ
│   │       │   └── eval
│   │       │       ├── with_genai_in_jap_prompt.txt // 日本語でのプロンプト
│   │       │       └── with_genai_prompt.txt       // 英語でのプロンプト
│   │       └── src
│   │           └── sample.txt      // サンプルデータ
│   ├── refac                        // refacコマンド関連ファイル
│   │   ├── refac_cmd.go             // refacコマンドオブジェクト
│   │   ├── refac_cmd_action.go      // refacコマンドのアクション（ロジック）
│   │   └── utils                    // リファクタリングユーティリティ
│   │       └── devide_code_and_text.go // コードとテキストの分割ロジック
│   ├── root.go                      // CLIアプリケーション全体のエントリーポイント
│   └── shared                       // eval, refac 両コマンドで共有するロジック
│       ├── add_desc_to_src.go       // ソースコードに説明を追加するロジック
│       └── add_desc_to_src_test.go  // そのテスト
├── go.mod                           // モジュール依存関係
├── go.sum                           // 依存関係のバージョン固定
├── internal                         // アプリケーション内部ロジック
│   ├── config                       // 設定管理
│   │   └── config.go                // 設定ファイル処理
│   ├── domain                       // ドメインロジック
│   │   ├── evaluation               // 評価ロジック
│   │   │   ├── evaluation_interface.go // 評価ロジックの抽象型インターフェース
│   │   │   ├── evaluation_with_genai.go // 英語対応評価ロジック
│   │   │   ├── evaluation_with_genai_in_jap.go // 日本語対応評価ロジック
│   │   │   ├── evaluation_with_genai_in_jap_test.go // 日本語評価ロジックのテスト
│   │   │   ├── evaluation_with_genai_test.go      // 英語評価ロジックのテスト
│   │   │   ├── instruction_text      // 評価指示用テキスト
│   │   │   │   ├── genai_instruction.txt         // 英語の評価指示
│   │   │   │   └── genai_instruction_in_jap.txt  // 日本語の評価指示
│   │   │   └── testdata              // 評価用テストデータ
│   │   │       └── prompt
│   │   │           ├── with_genai_in_jap_prompt.txt // 日本語プロンプト
│   │   │           └── with_genai_prompt.txt       // 英語プロンプト
│   │   ├── genai_interface.go       // GenAIサービスの抽象型
│   │   ├── genai_mock.go            // GenAIモック実装
│   │   └── refactoring              // リファクタリングロジック
│   │       ├── diff                 // 差分検出ロジック
│   │       │   ├── cmp_differ.go    // 差分比較ロジック
│   │       │   └── differ_interface.go // 差分検出インターフェース
│   │       ├── refactoring_interface.go // リファクタリング抽象型
│   │       └── refactoring_with_genai.go // GenAIを使ったリファクタリングロジック
│   ├── gateway                      // 外部サービスへのアダプター
│   │   └── api                      // 利用する外部API
│   │       └── gemini
│   │           └── gemini.go        // Gemini APIクライアント
│   └── presenter                    // プレゼンター（出力ロジック）
│       ├── eval_console_printer.go  // eval結果のコンソール出力
│       ├── eval_printer_interface.go // eval結果の出力インターフェース
│       ├── eval_printer_mock.go     // eval出力のモック
│       ├── indicater                // スピナーなどのインジケーター
│       │   └── indicater.go         // インジケーター表示
│       ├── refac_console_printer.go // refac結果のコンソール出力
│       ├── refac_file_overwriter.go // refac結果のファイル上書き
│       ├── refac_overwriter_interface.go // refac出力の上書きインターフェース
│       └── refac_printer_interface.go   // refac結果の出力インターフェース
├── main.go                          // アプリケーションのメインエントリーポイント
└── pkg                              // 汎用的なロジック
    └── load_file
        ├── load_file.go             // ファイル読み込みロジック
        ├── load_file_test.go        // そのテスト
        └── testdata                 // ファイル読み込み用のテストデータ
            └── sample.txt           // サンプルデータ

func Execute(ctx context.Context, cfg *config.Config) error {
	// geminiを初期化
	gemini := gemini.NewGemini(cfg.GeminiConfig, ctx)
	app := &cli.App{
		Name:        "refacgo",
		Version:     version,
		Description: "A Go-based command-line tool that evaluates the code in a specified Go file and provides refactoring suggestions powered by AI",
		Commands: []*cli.Command{
			eval.EvalCmd(ctx, gemini, presenter.NewEvalConsolePrinter()),
			refac.RefacCmd(ctx, gemini, diff.NewCmpDiffer(), presenter.NewRefacConsolePrinter(), presenter.NewRefacFileOverWriter()),
		},
	}
	if err := app.RunContext(ctx, os.Args); err != nil {
		return err
	}
	return nil
}

func EvalCmd(ctx context.Context, genAI domain.GenAI, evalPresenter evaluation.EvalPrinter) *cli.Command {
	return &cli.Command{
		Name:        "evaluate",
		Aliases:     []string{"eval"},

		//　省略

        // アクション
		Action: func(cCtx *cli.Context) error {
			evalCmdAction := initEvalCmdAction(cCtx, genAI, evalPresenter)
			if err := evalCmdAction.run(cCtx, ctx); err != nil {
				return err
			}
			return nil
		},
	}
}

func (eca *evalCmdAction) run(cCtx *cli.Context, ctx context.Context) error {
	if cCtx.NArg() != 1 {
		return errors.New("only one argument, the filename, is required")
	}
	// ファイル名（パス）を引数から取得
	filename := cCtx.Args().Get(0)
	if strings.HasPrefix(filename, `"`) || strings.HasSuffix(filename, `'`) {
		filename = filename[1 : len(filename)-1]
	}
	// 引数のファイルを読み込んで、バイトスライスを格納
	src, err := loadfile.LoadExternal(filename)
	if err != nil {
		return err
	}
	// descフラグから文字列を取得し、ソースに追加
	desc := cCtx.String("description")
	// フラグから""が帰ってきた時はそのままソースはそのまま返る
	src = shared.AddDescToSrc(src, desc)
	// Evaluateの結果をモジュール間で逐次出力するためのチャネル
	ch := make(chan string)
	// ビジネスロジック
	// 結果をストリームでチャネルに送信する
	err = eca.Evalueation.Evaluate(ctx, src, filename, ch)
	if err != nil {
		return err
	}
	// チャネルからストリームで受信する
	eca.EvalPresenter.Print(ctx, ch)

	return nil
}

type Evaluation interface {
	Evaluate(ctx context.Context, src []byte, filename string, ch chan<- string) error
}

type EvaluationWithGenAI struct {
	genAI domain.GenAI
}

func NewEvaluationWithGenAI(genAI domain.GenAI) *EvaluationWithGenAI {
	return &EvaluationWithGenAI{
		genAI: genAI,
	}
}

func (ev *EvaluationWithGenAI) Evaluate(ctx context.Context, src []byte, filename string, ch chan<- string) error {
	instruction, err := loadfile.LoadInternal("./instruction_text/genai_instruction.txt")
	if err != nil {
		panic(err)
	}
	prompt := fmt.Sprintf("The name of this file is %q.\n\n%v\n\n", filename, string(instruction))
	go func() error {
		err = ev.genAI.StreamQueryResults(ctx, src, prompt, ch)
		if err != nil {
			return err
		}
		return nil
	}()
	return nil
}

type EvalPrinter interface {
	Print(ctx context.Context, ch <-chan string) error
}

func (ep *EvalConsolePrinter) Print(ctx context.Context, ch <-chan string) error {
	is := ep.indicater.Spinner
	is.Suffix = "  Waiting for evaluating..."
	is.Start()
	defer is.Stop() // 処理の最後に必ずスピナーを停止する
	<-ch            // チャネルから受信するまではブロッキング
	is.Stop()
	for text := range ch {
		fmt.Println(text)
	}
	return nil
}

// アプリケーション内で利用する内部リソースを読み込む関数
func LoadInternal(relativePath string) ([]byte, error) {
	// 呼び出しもとのパスを得る
	_, caller_path, _, ok := runtime.Caller(1)
	if !ok {
		return nil, fmt.Errorf("failed to get caller information")
	}
	basePath := filepath.Dir(caller_path)
	absPath := filepath.Join(basePath, relativePath)
	f, err := os.Open(absPath)
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	// バッファを持った空のバイト配列
	var buf bytes.Buffer
	// 行単位でファイルを読み込む
	scannar := bufio.NewScanner(f)
	// 一行ごとにループ
	for scannar.Scan() {
		// bufに書き込み
		buf.Write(scannar.Bytes())
		// 文末に改行
		buf.WriteByte('\n') //1バイト書き込む
	}
	return buf.Bytes(), nil
}

//go:embed testdata/prompt/with_genai_prompt.txt
var expectedPrompt []byte

// マークダウンテキストにおけるコードブロックの内容を抜き出す正規表現
var codeBlockRegex = regexp.MustCompile("```[a-zA-Z ]*\n*([\\s\\S]*?)```")

func DevideCodeAndText(mix string) (code, text string, err error) {
  m := codeBlockRegex.FindStringSubmatch(mix)
  // コードブロックが含まれていなかった場合はエラーを返す
  if len(m) == 0 {
  	return "", "", errors.New("failed to match codeblock in md text")
  }
  // コードブロックにマッチした文字列
  code = m[1]
  // mixからコードブロックを削除した文字列
  text = codeBlockRegex.ReplaceAllString(mix, "")

  return code, text, nil
}

//go:embed testdata/mix_of_code_and_text.txt
var mix string

//go:embed testdata/only_text.txt
var onlyText string

//go:embed testdata/devided_code.txt
var devidedCode string

//go:embed testdata/devided_text.txt
var devidedText string

func TestDecideCodeAndText(t *testing.T) {
	t.Parallel()
	type want struct {
		code string
		text string
	}
	tests := []struct {
		name    string
		arg     string
		want    want
		wantErr bool
	}{
		{
			name: "引数にとった文字列をコードとテキストに分離して返す",
			arg:  mix,
			want: want{
				code: devidedCode,
				text: devidedText,
			},
			wantErr: false,
		},
		{
			name:    "引数にとった文字列にコードブロックがない場合、エラーをかえす",
			arg:     onlyText,
			wantErr: true,
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			code, text, err := DevideCodeAndText(tt.arg)
			fmt.Println(code)
			if (err != nil) != tt.wantErr {
				t.Error(err)
				return
			}
			if diff := cmp.Diff(tt.want.code, code); diff != "" {
				t.Errorf("DevideCodeAndText() return code mismatch (-want +got): %s", diff)
			}
			if diff := cmp.Diff(tt.want.text, text); diff != "" {
				t.Errorf("DevideCodeAndText() return text mismatch (-want +got): %s", diff)
			}

		})
	}
}

func (rca *refacCmdAction) run(cCtx *cli.Context, ctx context.Context) error {
	if cCtx.NArg() != 1 {
		return errors.New("only one argument, the filename, is required")
	}
	// ファイル名（パス）を引数から取得し読み込む
	filename := cCtx.Args().Get(0)
	if strings.HasPrefix(filename, `"`) || strings.HasSuffix(filename, `'`) {
		filename = filename[1 : len(filename)-1]
	}
	originSrc, err := loadfile.LoadFile(filename)
	if err != nil {
		return err
	}
	// descフラグから文字列を取得し、ソースコードに追加
	desc := cCtx.String("description")
	originSrcWithDesc := shared.AddDescToSrc(originSrc, desc)
	// リファクタリングする
	result, err := rca.refactoring.Refactor(ctx, originSrcWithDesc, filename)
	if err != nil {
		return err
	}
	// リファクタリング結果をテキスト/コードに分ける
	code, text, err := utils.DevideCodeAndText(result)
	if err != nil {
		return err
	}
	// 差分を検出
	diff := rca.differ.Diff(string(originSrc), code)
	// ファイル元を書き込み権限で開く
	f, err := os.Create(filename)
	if err != nil {
		return err
	}
	defer f.Close()
	// ファイルへの上書き
	// ヘッダーコメントを付加して上書きする
	rca.refacOverWriter.OverWriteWithHeaderComment(f, code)
	// テキスト・差分を表示
	rca.refacPrinter.Print(text, diff)
	// 上書きを確定するかどうか
	if utils.DecideToApply() {
		rca.refacOverWriter.OverWrite(f, code)
	} else {
		rca.refacOverWriter.OverWrite(f, string(originSrc))
	}
	return nil
}

//go:embed instruction_text/genai_instruction.txt
var instruction string

func (rf *RefactoringWithGenAI) Refactor(ctx context.Context, src []byte, filename string, ch chan<- string) error {
	prompt := fmt.Sprintf("The name of this file is %q.\n\n%v\n\n", filename, instruction)
	if err := rf.genAI.QueryResuluts(ctx, src, prompt, ch); err != nil {
		return err
	}
	return nil
}

func (gc *Gemini) QueryResuluts(ctx context.Context, src []byte, prompt string, ch chan<- string) error {
	// client & modelが何らかの理由でnilの場合は早期リターン
	if gc.client == nil || gc.model == nil {
		return errors.New("connection to Gemini failed")
	}
	// 実行が終わったらクライアントをクローズしておく
	defer func() error {
		if err := gc.client.Close(); err != nil {
			return err
		}
		return nil
	}()

	// 受け取ったバイト配列を文字列にしたものをラップ
	code := genai.Text(string(src))
	// プロンプトをラップ
	promptText := genai.Text(prompt)
	resp, err := gc.model.GenerateContent(ctx, promptText, code)
	if err != nil {
		return err
	}
	// 送信チャネルをクローズ
	defer close(ch)
	for _, cand := range resp.Candidates {
		if cand.Content != nil {
			for _, part := range cand.Content.Parts {
				// Text型の場合のみレスポンス文字列に格納する
				switch p := part.(type) {
				case genai.Text:
					ch <- string(p)
				}
			}
		}
	}
	return nil
}

 % go install github.com/kakkky/refacgo@latest
go: downloading github.com/kakkky/refacgo v0.1.0