@dannylee1020/kkt 0.5.0

package/internal/workflow/init.go

@@ -0,0 +1,164 @@
+package workflow
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+const (
+	instructionStart = "<!-- kkt-workflow:start -->"
+	instructionEnd   = "<!-- kkt-workflow:end -->"
+)
+
+type InitPlan struct {
+	Agent  string
+	Path   string
+	Remove bool
+}
+
+func UninstallPlans(agent string) ([]InitPlan, error) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return nil, err
+	}
+	return UninstallPlansWithHome(agent, home)
+}
+
+func UninstallPlansWithHome(agent, home string) ([]InitPlan, error) {
+	targets, err := expandAgent(agent)
+	if err != nil {
+		return nil, err
+	}
+
+	plans := []InitPlan{}
+	for _, target := range targets {
+		plans = append(plans, uninstallPlansForTarget(target, home)...)
+	}
+	if needsLegacyCleanup(targets) {
+		plans = append(plans, legacyCleanupPlans(home)...)
+	}
+	return dedupePlans(plans), nil
+}
+
+func uninstallPlansForTarget(agent, home string) []InitPlan {
+	plans := []InitPlan{
+		{
+			Agent:  agent,
+			Path:   filepath.Join(home, instructionPath(agent)),
+			Remove: true,
+		},
+	}
+	if usesInstructionReference(agent) {
+		plans = append(plans, InitPlan{
+			Agent:  agent,
+			Path:   filepath.Join(home, kktInstructionPath(agent)),
+			Remove: true,
+		})
+	}
+	return plans
+}
+
+func expandAgent(agent string) ([]string, error) {
+	switch agent {
+	case "all":
+		return []string{"codex", "claude", "opencode", "pi"}, nil
+	case "codex", "claude", "opencode", "pi":
+		return []string{agent}, nil
+	default:
+		return nil, fmt.Errorf("unsupported agent %q", agent)
+	}
+}
+
+func instructionPath(agent string) string {
+	switch agent {
+	case "codex":
+		return filepath.Join(".codex", "AGENTS.md")
+	case "claude":
+		return filepath.Join(".claude", "CLAUDE.md")
+	case "opencode":
+		return filepath.Join(".config", "opencode", "AGENTS.md")
+	case "pi":
+		return filepath.Join(".pi", "agent", "AGENTS.md")
+	}
+	return ""
+}
+
+func kktInstructionPath(agent string) string {
+	switch agent {
+	case "codex":
+		return filepath.Join(".codex", "KKT.md")
+	case "claude":
+		return filepath.Join(".claude", "KKT.md")
+	}
+	return ""
+}
+
+func usesInstructionReference(agent string) bool {
+	return agent == "codex" || agent == "claude"
+}
+
+func needsLegacyCleanup(agents []string) bool {
+	for _, agent := range agents {
+		switch agent {
+		case "codex", "opencode", "pi":
+			return true
+		}
+	}
+	return false
+}
+
+func legacyCleanupPlans(home string) []InitPlan {
+	return []InitPlan{
+		{
+			Agent:  "legacy",
+			Path:   filepath.Join(home, ".agents", "AGENTS.md"),
+			Remove: true,
+		},
+		{
+			Agent:  "legacy",
+			Path:   filepath.Join(home, ".agents", "KKT.md"),
+			Remove: true,
+		},
+	}
+}
+
+func dedupePlans(plans []InitPlan) []InitPlan {
+	seen := map[string]bool{}
+	deduped := []InitPlan{}
+	for _, plan := range plans {
+		key := fmt.Sprintf("%t:%s", plan.Remove, plan.Path)
+		if seen[key] {
+			continue
+		}
+		seen[key] = true
+		deduped = append(deduped, plan)
+	}
+	return deduped
+}
+
+func RemoveInstruction(path string) (bool, error) {
+	existingBytes, err := os.ReadFile(path)
+	if os.IsNotExist(err) {
+		return false, nil
+	}
+	if err != nil {
+		return false, err
+	}
+	existing := string(existingBytes)
+	start := strings.Index(existing, instructionStart)
+	end := strings.Index(existing, instructionEnd)
+	if start < 0 || end < 0 || end < start {
+		return false, nil
+	}
+	end += len(instructionEnd)
+	next := strings.Trim(existing[:start]+existing[end:], "\n")
+	if next != "" {
+		next += "\n"
+	}
+	if next == existing {
+		return false, nil
+	}
+	return true, os.WriteFile(path, []byte(next), 0o644)
+}

package/internal/workflow/init_test.go

@@ -0,0 +1,113 @@
+package workflow
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestRemoveInstructionPreservesExistingContent(t *testing.T) {
+	root := t.TempDir()
+	path := filepath.Join(root, "AGENTS.md")
+	existing := strings.Join([]string{
+		"# Existing",
+		"",
+		instructionStart,
+		"# KKT Workflow",
+		instructionEnd,
+		"",
+		"Keep this.",
+		"",
+	}, "\n")
+	if err := os.WriteFile(path, []byte(existing), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	changed, err := RemoveInstruction(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !changed {
+		t.Fatal("RemoveInstruction should report changed")
+	}
+	result, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(result)
+	if strings.Contains(text, instructionStart) || strings.Contains(text, instructionEnd) {
+		t.Fatal("KKT markers were not removed")
+	}
+	if !strings.Contains(text, "# Existing") || !strings.Contains(text, "Keep this.") {
+		t.Fatal("existing content was not preserved")
+	}
+}
+
+func TestRemoveInstructionIgnoresMissingOrUnmanagedFiles(t *testing.T) {
+	root := t.TempDir()
+	missingChanged, err := RemoveInstruction(filepath.Join(root, "missing.md"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if missingChanged {
+		t.Fatal("missing file should not report changed")
+	}
+
+	path := filepath.Join(root, "AGENTS.md")
+	if err := os.WriteFile(path, []byte("# Existing\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	unmanagedChanged, err := RemoveInstruction(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if unmanagedChanged {
+		t.Fatal("unmanaged file should not report changed")
+	}
+}
+
+func TestUninstallPlansUsesGlobalAgentLocations(t *testing.T) {
+	home := t.TempDir()
+	plans, err := UninstallPlansWithHome("all", home)
+	if err != nil {
+		t.Fatal(err)
+	}
+	paths := map[string]bool{}
+	for _, plan := range plans {
+		if !plan.Remove {
+			t.Fatalf("uninstall plan should only contain remove actions: %s", plan.Path)
+		}
+		paths[plan.Path] = true
+	}
+	expectedPaths := []string{
+		filepath.Join(home, ".codex", "AGENTS.md"),
+		filepath.Join(home, ".codex", "KKT.md"),
+		filepath.Join(home, ".claude", "CLAUDE.md"),
+		filepath.Join(home, ".claude", "KKT.md"),
+		filepath.Join(home, ".pi", "agent", "AGENTS.md"),
+		filepath.Join(home, ".config", "opencode", "AGENTS.md"),
+		filepath.Join(home, ".agents", "AGENTS.md"),
+		filepath.Join(home, ".agents", "KKT.md"),
+	}
+	for _, path := range expectedPaths {
+		if !paths[path] {
+			t.Fatalf("missing uninstall path: %s", path)
+		}
+	}
+}
+
+func TestUninstallPlansDedupesInstructionPaths(t *testing.T) {
+	home := t.TempDir()
+	plans, err := UninstallPlansWithHome("all", home)
+	if err != nil {
+		t.Fatal(err)
+	}
+	seen := map[string]bool{}
+	for _, plan := range plans {
+		if seen[plan.Path] {
+			t.Fatalf("duplicate instruction path: %s", plan.Path)
+		}
+		seen[plan.Path] = true
+	}
+}