rogee/renamer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: remove ai cmd

Browse Source
This commit is contained in:
Rogee
2025-11-05 09:44:42 +08:00
parent ad8ca2b1f7
commit bf7cfc8224
24 changed files with 0 additions and 3112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

195
tests/integration/ai_apply_undo_test.go
View File

@@ -1,195 +0,0 @@
package integration
import (
"bytes"
"context"
"encoding/json"
"os"
"path/filepath"
"strings"
"testing"
renamercmd "github.com/rogeecn/renamer/cmd"
"github.com/rogeecn/renamer/internal/ai/genkit"
"github.com/rogeecn/renamer/internal/ai/plan"
"github.com/rogeecn/renamer/internal/ai/prompt"
"github.com/rogeecn/renamer/internal/listing"
)
func TestAIApplyAndUndoFlow(t *testing.T) {
initialWorkflow := stubWorkflow{
response: prompt.RenameResponse{
Items: []prompt.RenameItem{
{
Original: "draft_one.txt",
Proposed: "001_initial.txt",
Sequence: 1,
},
{
Original: "draft_two.txt",
Proposed: "002_initial.txt",
Sequence: 2,
},
},
Model: "test-model",
},
}
genkit.OverrideWorkflowFactory(func(ctx context.Context, opts genkit.Options) (genkit.WorkflowRunner, error) {
return initialWorkflow, nil
})
t.Cleanup(genkit.ResetWorkflowFactory)
root := t.TempDir()
writeFile(t, filepath.Join(root, "draft_one.txt"))
writeFile(t, filepath.Join(root, "draft_two.txt"))
planPath := filepath.Join(root, "renamer.plan.json")
preview := renamercmd.NewRootCommand()
var previewOut, previewErr bytes.Buffer
preview.SetOut(&previewOut)
preview.SetErr(&previewErr)
preview.SetArgs([]string{
"ai",
"--path", root,
"--dry-run",
})
if err := preview.Execute(); err != nil {
if previewOut.Len() > 0 {
t.Logf("preview stdout: %s", previewOut.String())
}
if previewErr.Len() > 0 {
t.Logf("preview stderr: %s", previewErr.String())
}
t.Fatalf("initial preview: %v", err)
}
data, err := os.ReadFile(planPath)
if err != nil {
t.Fatalf("read plan: %v", err)
}
var exported prompt.RenameResponse
if err := json.Unmarshal(data, &exported); err != nil {
t.Fatalf("unmarshal plan: %v", err)
}
if len(exported.Items) != 2 {
t.Fatalf("expected two plan items, got %d", len(exported.Items))
}
// Simulate operator edit.
exported.Items[0].Proposed = "001_final-one.txt"
exported.Items[1].Proposed = "002_final-two.txt"
exported.Items[0].Notes = "custom edit"
modified, err := json.MarshalIndent(exported, "", " ")
if err != nil {
t.Fatalf("marshal modified plan: %v", err)
}
if err := os.WriteFile(planPath, append(modified, '\n'), 0o644); err != nil {
t.Fatalf("write modified plan: %v", err)
}
req := &listing.ListingRequest{WorkingDir: root}
if err := req.Validate(); err != nil {
t.Fatalf("validate listing request: %v", err)
}
currentCandidates, err := plan.CollectCandidates(context.Background(), req)
if err != nil {
t.Fatalf("collect candidates: %v", err)
}
filtered := make([]plan.Candidate, 0, len(currentCandidates))
for _, cand := range currentCandidates {
if strings.EqualFold(cand.OriginalPath, filepath.Base(planPath)) {
continue
}
filtered = append(filtered, cand)
}
originals := make([]string, 0, len(filtered))
for _, cand := range filtered {
originals = append(originals, cand.OriginalPath)
}
validator := plan.NewValidator(originals, prompt.NamingPolicyConfig{Casing: "kebab"}, nil)
if _, err := validator.Validate(exported); err != nil {
t.Fatalf("pre-validation of edited plan: %v", err)
}
previewEdited := renamercmd.NewRootCommand()
var editedOut, editedErr bytes.Buffer
previewEdited.SetOut(&editedOut)
previewEdited.SetErr(&editedErr)
previewEdited.SetArgs([]string{
"ai",
"--path", root,
"--dry-run",
})
if err := previewEdited.Execute(); err != nil {
if editedOut.Len() > 0 {
t.Logf("edited stdout: %s", editedOut.String())
}
if editedErr.Len() > 0 {
t.Logf("edited stderr: %s", editedErr.String())
}
t.Fatalf("preview edited plan: %v", err)
}
if !strings.Contains(editedOut.String(), "001_final-one.txt") {
t.Fatalf("expected edited preview to show final name, got: %s", editedOut.String())
}
applyCmd := renamercmd.NewRootCommand()
var applyOut, applyErr bytes.Buffer
applyCmd.SetOut(&applyOut)
applyCmd.SetErr(&applyErr)
applyCmd.SetArgs([]string{
"ai",
"--path", root,
"--yes",
})
if err := applyCmd.Execute(); err != nil {
if applyOut.Len() > 0 {
t.Logf("apply stdout: %s", applyOut.String())
}
if applyErr.Len() > 0 {
t.Logf("apply stderr: %s", applyErr.String())
}
t.Fatalf("apply plan: %v", err)
}
if _, err := os.Stat(filepath.Join(root, "001_final-one.txt")); err != nil {
t.Fatalf("expected renamed file: %v", err)
}
if _, err := os.Stat(filepath.Join(root, "002_final-two.txt")); err != nil {
t.Fatalf("expected renamed file: %v", err)
}
undo := renamercmd.NewRootCommand()
var undoOut bytes.Buffer
undo.SetOut(&undoOut)
undo.SetErr(&undoOut)
undo.SetArgs([]string{"undo", "--path", root})
if err := undo.Execute(); err != nil {
t.Fatalf("undo command: %v", err)
}
if _, err := os.Stat(filepath.Join(root, "draft_one.txt")); err != nil {
t.Fatalf("expected original file after undo: %v", err)
}
if _, err := os.Stat(filepath.Join(root, "draft_two.txt")); err != nil {
t.Fatalf("expected original file after undo: %v", err)
}
}
func writeFile(t *testing.T, path string) {
t.Helper()
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
t.Fatalf("mkdir %s: %v", path, err)
}
if err := os.WriteFile(path, []byte("data"), 0o644); err != nil {
t.Fatalf("write file %s: %v", path, err)
}
}

78
tests/integration/ai_policy_validation_test.go
View File

@@ -1,78 +0,0 @@
package integration
import (
"bytes"
"context"
"os"
"path/filepath"
"strings"
"testing"
renamercmd "github.com/rogeecn/renamer/cmd"
"github.com/rogeecn/renamer/internal/ai/genkit"
"github.com/rogeecn/renamer/internal/ai/prompt"
)
type violatingWorkflow struct{}
func (violatingWorkflow) Run(ctx context.Context, req genkit.Request) (genkit.Result, error) {
return genkit.Result{
Response: prompt.RenameResponse{
Items: []prompt.RenameItem{
{
Original: "video.mov",
Proposed: "001_clickbait-offer.mov",
Sequence: 1,
},
},
Warnings: []string{"model returned promotional phrasing"},
},
}, nil
}
func TestAIPolicyValidationFailsWithActionableMessage(t *testing.T) {
genkit.OverrideWorkflowFactory(func(ctx context.Context, opts genkit.Options) (genkit.WorkflowRunner, error) {
return violatingWorkflow{}, nil
})
t.Cleanup(genkit.ResetWorkflowFactory)
rootDir := t.TempDir()
createAIPolicyFixture(t, filepath.Join(rootDir, "video.mov"))
rootCmd := renamercmd.NewRootCommand()
var stdout, stderr bytes.Buffer
rootCmd.SetOut(&stdout)
rootCmd.SetErr(&stderr)
rootCmd.SetArgs([]string{
"ai",
"--path", rootDir,
"--dry-run",
})
err := rootCmd.Execute()
if err == nil {
t.Fatalf("expected policy violation error")
}
lines := stderr.String()
if !strings.Contains(lines, "Policy violation (banned)") {
t.Fatalf("expected banned token message in stderr, got: %s", lines)
}
if !strings.Contains(err.Error(), "policy violations") {
t.Fatalf("expected error to mention policy violations, got: %v", err)
}
if stdout.Len() != 0 {
t.Logf("stdout: %s", stdout.String())
}
}
func createAIPolicyFixture(t *testing.T, path string) {
t.Helper()
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
t.Fatalf("mkdir %s: %v", path, err)
}
if err := os.WriteFile(path, []byte("demo"), 0o644); err != nil {
t.Fatalf("write file %s: %v", path, err)
}
}

115
tests/integration/ai_preview_flow_test.go
View File

@@ -1,115 +0,0 @@
package integration
import (
"bytes"
"context"
"encoding/json"
"os"
"path/filepath"
"strings"
"testing"
renamercmd "github.com/rogeecn/renamer/cmd"
"github.com/rogeecn/renamer/internal/ai/genkit"
"github.com/rogeecn/renamer/internal/ai/prompt"
)
type stubWorkflow struct {
response prompt.RenameResponse
}
func (s stubWorkflow) Run(ctx context.Context, req genkit.Request) (genkit.Result, error) {
return genkit.Result{Response: s.response}, nil
}
func TestAIPreviewFlowRendersSequenceTable(t *testing.T) {
workflow := stubWorkflow{
response: prompt.RenameResponse{
Items: []prompt.RenameItem{
{
Original: "promo SALE 01.JPG",
Proposed: "001_summer-session.jpg",
Sequence: 1,
Notes: "Removed promotional flair",
},
{
Original: "family_photo.png",
Proposed: "002_family-photo.png",
Sequence: 2,
Notes: "Normalized casing",
},
},
Warnings: []string{"AI warning: trimmed banned tokens"},
PromptHash: "",
},
}
genkit.OverrideWorkflowFactory(func(ctx context.Context, opts genkit.Options) (genkit.WorkflowRunner, error) {
return workflow, nil
})
defer genkit.ResetWorkflowFactory()
root := t.TempDir()
createAIPreviewFile(t, filepath.Join(root, "promo SALE 01.JPG"))
createAIPreviewFile(t, filepath.Join(root, "family_photo.png"))
t.Setenv("OPENAI_TOKEN", "test-token")
rootCmd := renamercmd.NewRootCommand()
var stdout, stderr bytes.Buffer
rootCmd.SetOut(&stdout)
rootCmd.SetErr(&stderr)
exportPath := filepath.Join(root, "renamer.plan.json")
rootCmd.SetArgs([]string{
"ai",
"--path", root,
"--dry-run",
"--debug-genkit",
})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("command execute: %v", err)
}
data, err := os.ReadFile(exportPath)
if err != nil {
t.Fatalf("read exported plan: %v", err)
}
var exported prompt.RenameResponse
if err := json.Unmarshal(data, &exported); err != nil {
t.Fatalf("unmarshal exported plan: %v", err)
}
if len(exported.Items) != len(workflow.response.Items) {
t.Fatalf("expected exported items %d, got %d", len(workflow.response.Items), len(exported.Items))
}
out := stdout.String()
if !strings.Contains(out, "SEQ") || !strings.Contains(out, "ORIGINAL") || !strings.Contains(out, "SANITIZED") {
t.Fatalf("expected table headers in output, got:\n%s", out)
}
if !strings.Contains(out, "001") || !strings.Contains(out, "promo SALE 01.JPG") || !strings.Contains(out, "001_summer-session.jpg") {
t.Fatalf("expected first entry in output, got:\n%s", out)
}
if !strings.Contains(out, "removed: promo sale") {
t.Fatalf("expected sanitization notes in output, got:\n%s", out)
}
errOut := stderr.String()
if !strings.Contains(errOut, "Prompt hash:") {
t.Fatalf("expected prompt hash in debug output, got:\n%s", errOut)
}
if !strings.Contains(errOut, "AI warning: trimmed banned tokens") {
t.Fatalf("expected warning surfaced in debug output, got:\n%s", errOut)
}
}
func createAIPreviewFile(t *testing.T, path string) {
t.Helper()
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
t.Fatalf("mkdir %s: %v", path, err)
}
if err := os.WriteFile(path, []byte("test"), 0o644); err != nil {
t.Fatalf("write file %s: %v", path, err)
}
}