command_plan_new.go

package tasked

import (
	"fmt"
	"os"
	"strings"
	"time"

	"github.com/dhamidi/tasked/planner"
	"github.com/spf13/cobra"
)

var planAutoSteps bool

var PlanNewCmd = &cobra.Command{
	Use:   "new [plan-name]",
	Short: "Create a new plan (with optional auto-detected steps)",
	Long: `Create a new plan with the specified name. The plan will be created
in the database and can then be populated with steps using other plan commands.

When run without a plan name, a default name is generated based on the project name and date.
The command will automatically analyze the current directory for issues (TODOs, missing tests,
uncommitted changes) and offer to auto-generate steps.`,
	Args: cobra.MaximumNArgs(1),
	RunE: RunPlanNew,
}

func init() {
	PlanNewCmd.Flags().BoolVar(&planAutoSteps, "auto-steps", false, "Automatically generate steps from detected issues")
}

func RunPlanNew(cmd *cobra.Command, args []string) error {
	// Detect context automatically
	ctx, err := GlobalSettings.GetOrCreateContext()
	if err != nil {
		return fmt.Errorf("failed to detect context: %w", err)
	}

	// Determine plan name
	planName := ""
	if len(args) > 0 {
		planName = args[0]
	} else {
		// Generate default plan name: {project-name}-{date}
		dateStr := time.Now().Format("2006-01-02")
		planName = fmt.Sprintf("%s-%s", ctx.ProjectName, dateStr)
	}

	fmt.Printf("Detected context: %s", ctx.CurrentPath)
	if ctx.IsGitRepo {
		fmt.Printf(" (git root: %s)", ctx.GitRoot)
	}
	fmt.Printf("\n")

	// Get the database file path from settings
	dbPath := GlobalSettings.GetDatabaseFile()

	// Initialize the planner
	p, err := planner.New(dbPath)
	if err != nil {
		return fmt.Errorf("failed to initialize planner: %w", err)
	}
	defer p.Close()

	// Create the new plan
	plan, err := p.Create(planName)
	if err != nil {
		return fmt.Errorf("failed to create plan: %w", err)
	}

	// Set context metadata on the plan
	plan.ContextPath = ctx.CurrentPath
	plan.GitRoot = ctx.GitRoot
	plan.ProjectName = ctx.ProjectName

	// Analyze directory for issues
	fmt.Printf("Scanning directory for issues...")
	issues, err := planner.AnalyzeDirectory(ctx.CurrentPath)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Warning: could not analyze directory: %v\n", err)
		issues = &planner.IssuesFound{}
	}
	fmt.Printf("\n")

	// Summary of found issues
	totalIssues := len(issues.Todos) + len(issues.MissingTests) + len(issues.Uncommitted)
	if totalIssues > 0 {
		fmt.Printf("Found %d issues to address:\n", totalIssues)
		if len(issues.Todos) > 0 {
			fmt.Printf("  - %d TODO comments in code\n", len(issues.Todos))
		}
		if len(issues.MissingTests) > 0 {
			fmt.Printf("  - %d missing test files\n", len(issues.MissingTests))
		}
		if len(issues.Uncommitted) > 0 {
			fmt.Printf("  - %d uncommitted changes\n", len(issues.Uncommitted))
		}
		fmt.Printf("\n")
	}

	// Auto-generate steps if requested or if no name was provided and issues were found
	shouldAutoGenerate := planAutoSteps || (len(args) == 0 && totalIssues > 0)
	if shouldAutoGenerate && totalIssues > 0 {
		fmt.Printf("Creating plan '%s' with auto-generated steps...\n", planName)

		// Generate steps from issues
		generateStepsFromIssues(plan, issues)

		fmt.Printf("Generated %d steps from detected issues:\n", len(plan.Steps))
		for i, step := range plan.Steps {
			fmt.Printf("  %d. [%s] %s\n", i+1, step.Status(), step.ID())
		}
		fmt.Printf("\n")
	} else {
		fmt.Printf("Creating empty plan '%s'\n", planName)
	}

	// Save the plan to the database
	if err := p.Save(plan); err != nil {
		return fmt.Errorf("failed to save plan: %w", err)
	}

	if shouldAutoGenerate && totalIssues > 0 {
		fmt.Printf("Run 'tasked plan inspect %s' to see all steps\n", planName)
	} else {
		fmt.Printf("Use 'tasked plan add-step %s <step-id> <desc> <acceptance...>' to add steps\n", planName)
	}

	return nil
}

// generateStepsFromIssues creates plan steps from detected issues
func generateStepsFromIssues(plan *planner.Plan, issues *planner.IssuesFound) {
	// Generate step counter
	stepCounter := 1

	// Add steps for TODOs
	for _, todo := range issues.Todos {
		stepID := fmt.Sprintf("fix-todo-%d", stepCounter)
		description := fmt.Sprintf("Fix TODO from %s:%d: %s", todo.File, todo.LineNumber, todo.Description)

		// Clean up file path for display
		fileDisplay := cleanFilePath(todo.File)

		// Generate acceptance criteria
		acceptance := []string{
			fmt.Sprintf("TODO comment in %s:%d removed or properly addressed", fileDisplay, todo.LineNumber),
		}

		// Add file reference
		references := []string{todo.File}

		plan.AddStep(stepID, description, acceptance, references)
		stepCounter++
	}

	// Add steps for missing tests
	for _, missingTest := range issues.MissingTests {
		stepID := fmt.Sprintf("add-test-%d", stepCounter)
		description := fmt.Sprintf("Add tests for %s", cleanFilePath(missingTest.SourceFile))

		acceptance := []string{
			fmt.Sprintf("Test file %s exists", cleanFilePath(missingTest.TestFile)),
			"Tests pass and provide good coverage",
		}

		references := []string{missingTest.SourceFile}

		plan.AddStep(stepID, description, acceptance, references)
		stepCounter++
	}

	// Add steps for uncommitted changes
	// Group files by status
	changesByStatus := make(map[string][]string)
	for _, change := range issues.Uncommitted {
		if change.Status != "?" { // Skip untracked files
			changesByStatus[change.Status] = append(changesByStatus[change.Status], cleanFilePath(change.File))
		}
	}

	// Add step for each group of changes
	for status, files := range changesByStatus {
		stepID := fmt.Sprintf("commit-%s-%d", strings.ToLower(status), stepCounter)
		var description string
		if len(files) == 1 {
			description = fmt.Sprintf("Complete work on %s", files[0])
		} else {
			description = fmt.Sprintf("Complete work on %d files", len(files))
		}

		acceptance := []string{
			"Changes are ready to commit",
			"All files are reviewed",
		}

		references := files

		plan.AddStep(stepID, description, acceptance, references)
		stepCounter++
	}
}

// cleanFilePath makes a file path more readable for display
func cleanFilePath(path string) string {
	ctx, _ := GlobalSettings.GetOrCreateContext()
	if ctx == nil {
		return path
	}

	// Try to make the path relative to context
	if ctx.CurrentPath != "" && strings.HasPrefix(path, ctx.CurrentPath) {
		relPath := strings.TrimPrefix(path, ctx.CurrentPath+"/")
		return relPath
	}

	return path
}