input

// cmd/pm/main.go
package main

import (
	"fmt"
	"os"
	"path/filepath"

	"github.com/yourusername/pm/internal/config"
	"github.com/yourusername/pm/internal/modules/management"
)

func main() {
	homeDir, err := os.UserHomeDir()
	if err != nil {
		fmt.Printf("Error getting home directory: %v\n", err)
		os.Exit(1)
	}

	configPath := filepath.Join(homeDir, ".config", "project-manager", "config.json")
	cfg, err := config.Load(configPath)
	if err != nil {
		fmt.Printf("Error loading config: %v\n", err)
		os.Exit(1)
	}

	manager := management.New(cfg)
	if err := manager.RunCommand(os.Args[1], os.Args[2]); err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
}

// internal/config/types.go
package config

type Component struct {
	Name     string            `json:"name"`
	Path     string            `json:"path"`
	Commands map[string]string `json:"commands"`
	Enabled  bool             `json:"enabled"`
}

type Project struct {
	Name       string      `json:"name"`
	Components []Component `json:"components"`
}

type Config struct {
	Projects []Project `json:"projects"`
}

// internal/config/config.go
package config

import (
	"encoding/json"
	"os"
	"path/filepath"
)

func Load(path string) (*Config, error) {
	data, err := os.ReadFile(path)
	if err != nil {
		if os.IsNotExist(err) {
			cfg := &Config{}
			if err := Save(cfg, path); err != nil {
				return nil, err
			}
			return cfg, nil
		}
		return nil, err
	}

	var cfg Config
	if err := json.Unmarshal(data, &cfg); err != nil {
		return nil, err
	}
	return &cfg, nil
}

func Save(cfg *Config, path string) error {
	dir := filepath.Dir(path)
	if err := os.MkdirAll(dir, 0755); err != nil {
		return err
	}

	data, err := json.MarshalIndent(cfg, "", "  ")
	if err != nil {
		return err
	}
	return os.WriteFile(path, data, 0644)
}

// internal/modules/management/types.go
package management

import (
	"time"

	"github.com/yourusername/pm/internal/config"
)

type ProcessState struct {
	ProjectName  string    `yaml:"projectName"`
	ComponentID  string    `yaml:"componentId"`
	Path         string    `yaml:"path"`
	Command      string    `yaml:"command"`
	CommandType  string    `yaml:"commandType"`
	PID          int       `yaml:"pid"`
	WindowID     string    `yaml:"windowId"`
	TabID        string    `yaml:"tabId"`
	StartTime    time.Time `yaml:"startTime"`
	LastSeen     time.Time `yaml:"lastSeen"`
	IsResponding bool      `yaml:"isResponding"`
}

type ProcessManager struct {
	StateFile string
	Processes map[string]ProcessState
}

// internal/modules/management/state.go
package management

import (
	"fmt"
	"os"
	"path/filepath"
	"time"

	"gopkg.in/yaml.v2"
)

func (pm *ProcessManager) LoadState() error {
	data, err := os.ReadFile(pm.StateFile)
	if err != nil {
		if os.IsNotExist(err) {
			pm.Processes = make(map[string]ProcessState)
			return nil
		}
		return err
	}

	return yaml.Unmarshal(data, &pm.Processes)
}

func (pm *ProcessManager) SaveState() error {
	dir := filepath.Dir(pm.StateFile)
	if err := os.MkdirAll(dir, 0755); err != nil {
		return err
	}

	data, err := yaml.Marshal(pm.Processes)
	if err != nil {
		return err
	}

	return os.WriteFile(pm.StateFile, data, 0644)
}

func (pm *ProcessManager) RegisterProcess(state ProcessState) error {
	key := fmt.Sprintf("%s-%s-%s", state.ProjectName, state.ComponentID, state.CommandType)
	state.StartTime = time.Now()
	state.LastSeen = time.Now()
	state.IsResponding = true
	pm.Processes[key] = state
	return pm.SaveState()
}

func (pm *ProcessManager) UpdateProcess(key string, isResponding bool) error {
	if proc, exists := pm.Processes[key]; exists {
		proc.LastSeen = time.Now()
		proc.IsResponding = isResponding
		pm.Processes[key] = proc
		return pm.SaveState()
	}
	return fmt.Errorf("process not found: %s", key)
}

func (pm *ProcessManager) StopProcess(projectName, componentID, commandType string) error {
	key := fmt.Sprintf("%s-%s-%s", projectName, componentID, commandType)
	if proc, exists := pm.Processes[key]; exists {
		if err := killProcess(proc.PID); err != nil {
			return err
		}
		delete(pm.Processes, key)
		return pm.SaveState()
	}
	return fmt.Errorf("process not found: %s", key)
}

// internal/modules/management/terminal.go
package management

import (
	"fmt"
	"os/exec"
	"strings"
)

type TerminalGroup struct {
	Path       string
	Components []TerminalComponent
}

type TerminalComponent struct {
	Name        string
	Command     string
	CommandType string
}

func runInTerminal(group *TerminalGroup, projectName string, pm *ProcessManager) error {
	script := fmt.Sprintf(`
		tell application "Terminal"
			set newWindow to do script "cd %s && echo '# %s - %s' && %s"
			set windowId to id of window 1
			return windowId
		end tell
	`, group.Path, projectName, group.Components[0].Name, group.Components[0].Command)

	output, err := exec.Command("osascript", "-e", script).Output()
	if err != nil {
		return err
	}
	windowID := strings.TrimSpace(string(output))

	state := ProcessState{
		ProjectName:  projectName,
		ComponentID:  group.Components[0].Name,
		Path:        group.Path,
		Command:     group.Components[0].Command,
		CommandType: group.Components[0].CommandType,
		WindowID:    windowID,
		TabID:       "1",
	}
	if err := pm.RegisterProcess(state); err != nil {
		return err
	}

	for i, comp := range group.Components[1:] {
		script := fmt.Sprintf(`
			tell application "Terminal"
				tell window id %s
					set newTab to do script "cd %s && echo '# %s - %s' && %s"
					return id of tab %d
				end tell
			end tell
		`, windowID, group.Path, projectName, comp.Name, comp.Command, i+2)

		output, err := exec.Command("osascript", "-e", script).Output()
		if err != nil {
			return err
		}
		tabID := strings.TrimSpace(string(output))

		state := ProcessState{
			ProjectName:  projectName,
			ComponentID:  comp.Name,
			Path:        group.Path,
			Command:     comp.Command,
			CommandType: comp.CommandType,
			WindowID:    windowID,
			TabID:       tabID,
		}
		if err := pm.RegisterProcess(state); err != nil {
			return err
		}
	}

	return nil
}

// internal/modules/management/manager.go
package management

import (
	"fmt"
	"os"
	"path/filepath"

	"github.com/yourusername/pm/internal/config"
)

type Manager struct {
	config  *config.Config
	procMgr *ProcessManager
}

func New(cfg *config.Config) *Manager {
	homeDir, _ := os.UserHomeDir()
	stateFile := filepath.Join(homeDir, ".config", "project-manager", "state.yaml")
	
	return &Manager{
		config: cfg,
		procMgr: &ProcessManager{
			StateFile: stateFile,
			Processes: make(map[string]ProcessState),
		},
	}
}

func (m *Manager) RunCommand(projectName, commandType string) error {
	if err := m.procMgr.LoadState(); err != nil {
		return fmt.Errorf("failed to load state: %v", err)
	}

	var project *config.Project
	for _, p := range m.config.Projects {
		if p.Name == projectName {
			project = &p
			break
		}
	}
	if project == nil {
		return fmt.Errorf("project %s not found", projectName)
	}

	terminalGroups := make(map[string]*TerminalGroup)
	
	for _, component := range project.Components {
		if !component.Enabled {
			continue
		}

		command, ok := component.Commands[commandType]
		if !ok {
			continue
		}

		absPath, err := filepath.Abs(component.Path)
		if err != nil {
			return fmt.Errorf("failed to resolve path for %s: %v", component.Name, err)
		}

		group, exists := terminalGroups[absPath]
		if !exists {
			group = &TerminalGroup{
				Path:       absPath,
				Components: make([]TerminalComponent, 0),
			}
			terminalGroups[absPath] = group
		}

		group.Components = append(group.Components, TerminalComponent{
			Name:        component.Name,
			Command:     command,
			CommandType: commandType,
		})
	}

	for _, group := range terminalGroups {
		if err := runInTerminal(group, projectName, m.procMgr); err != nil {
			return fmt.Errorf("failed to run in Terminal.app: %v", err)
		}
	}

	return nil
}