manifest.go

package main

import (
	"bytes"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"sort"
	"strings"
)

// ── types ────────────────────────────────────────────────────────────

type MirrorEntry struct {
	From    string   `json:"from"`
	To      string   `json:"to"`
	Exclude []string `json:"exclude,omitempty"`
}

type Manifest struct {
	Version     int            `json:"version"`
	Comment     string         `json:"comment,omitempty"`
	Directories []DirEntry     `json:"directories"`
	Symlinks    []SymlinkEntry `json:"symlinks,omitempty"`
	Mirrors     []MirrorEntry  `json:"mirrors,omitempty"`
	Skills      []SkillEntry   `json:"skills"`
}

type DirEntry struct {
	Name    string `json:"name"`
	Path    string `json:"path"`
	Comment string `json:"comment,omitempty"`
}

type SymlinkEntry struct {
	From string `json:"from"`
	To   string `json:"to"`
}

type SkillEntry struct {
	Name   string      `json:"name"`
	Target string      `json:"target"`
	Source SourceEntry `json:"source"`
	Note   string      `json:"note,omitempty"`
	extra  map[string]json.RawMessage
}

func (s *SkillEntry) UnmarshalJSON(data []byte) error {
	type alias SkillEntry
	if err := json.Unmarshal(data, (*alias)(s)); err != nil {
		return err
	}
	var raw map[string]json.RawMessage
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	for k, v := range raw {
		switch k {
		case "name", "target", "source", "note":
			continue
		default:
			if s.extra == nil {
				s.extra = make(map[string]json.RawMessage)
			}
			s.extra[k] = v
		}
	}
	return nil
}

func (s SkillEntry) MarshalJSON() ([]byte, error) {
	type alias SkillEntry
	base, err := json.Marshal(alias(s))
	if err != nil {
		return nil, err
	}
	if len(s.extra) == 0 {
		return base, nil
	}
	var merged map[string]json.RawMessage
	if err := json.Unmarshal(base, &merged); err != nil {
		return nil, err
	}
	for k, v := range s.extra {
		merged[k] = v
	}
	return json.Marshal(merged)
}

type SourceEntry struct {
	Type  string            `json:"type,omitempty"`
	Files map[string]string `json:"files,omitempty"`
	Repo  string            `json:"repo"`
	Ref   string            `json:"ref"`
	Path  string            `json:"path,omitempty"`
	extra map[string]json.RawMessage
}

func (s *SourceEntry) UnmarshalJSON(data []byte) error {
	type alias SourceEntry
	if err := json.Unmarshal(data, (*alias)(s)); err != nil {
		return err
	}
	var raw map[string]json.RawMessage
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	for k, v := range raw {
		switch k {
		case "type", "files", "repo", "ref", "path":
			continue
		default:
			if s.extra == nil {
				s.extra = make(map[string]json.RawMessage)
			}
			s.extra[k] = v
		}
	}
	return nil
}

func (s SourceEntry) MarshalJSON() ([]byte, error) {
	type alias SourceEntry
	base, err := json.Marshal(alias(s))
	if err != nil {
		return nil, err
	}
	if len(s.extra) == 0 {
		return base, nil
	}
	var merged map[string]json.RawMessage
	if err := json.Unmarshal(base, &merged); err != nil {
		return nil, err
	}
	for k, v := range s.extra {
		merged[k] = v
	}
	return json.Marshal(merged)
}

// ── lock ─────────────────────────────────────────────────────────────

type LockFile struct {
	Version int                  `json:"version"`
	Skills  map[string]LockSkill `json:"skills"`
}

type LockSkill struct {
	Commit      string `json:"commit"`
	Path        string `json:"path"`
	SourceHash  string `json:"sourceHash,omitempty"`
	ContentHash string `json:"contentHash,omitempty"`
}

// ── path helpers ─────────────────────────────────────────────────────

const specialTargetOMP = "omp"

func expandPath(p string) string {
	if len(p) > 1 && p[:2] == "~/" {
		home, _ := os.UserHomeDir()
		return filepath.Join(home, p[2:])
	}
	return p
}

func resolveOMPUserSkillsDir() string {
	if out, err := exec.Command("omp", "config", "path").Output(); err == nil {
		agentDir := strings.TrimSpace(string(out))
		if agentDir != "" {
			return filepath.Join(expandPath(agentDir), "skills")
		}
	}

	configDir := ".omp"
	if v := strings.TrimSpace(os.Getenv("PI_CONFIG_DIR")); v != "" {
		configDir = v
	}
	home, _ := os.UserHomeDir()
	return filepath.Join(home, configDir, "agent", "skills")
}

func targetExists(dirName string, dirs []DirEntry) bool {
	if dirName == specialTargetOMP {
		return true
	}
	for _, d := range dirs {
		if d.Name == dirName {
			return true
		}
	}
	return false
}

func resolveTargetPath(dirName string, dirs []DirEntry) string {
	if dirName == specialTargetOMP {
		return resolveOMPUserSkillsDir()
	}
	for _, d := range dirs {
		if d.Name == dirName {
			return expandPath(d.Path)
		}
	}
	return ""
}

// ── I/O ──────────────────────────────────────────────────────────────

// atomicWriteFile writes data to path atomically by writing to a temp file
// in the same directory (same filesystem) and renaming.
func atomicWriteFile(path string, data []byte, perm os.FileMode) error {
	// Resolve symlinks so writes land on the real file, not the symlink
	realPath := path
	if resolved, err := filepath.EvalSymlinks(path); err == nil {
		realPath = resolved
	} else if !os.IsNotExist(err) {
		// Symlink exists but can't resolve — try resolving parent dir
		if dir, err2 := filepath.EvalSymlinks(filepath.Dir(path)); err2 == nil {
			realPath = filepath.Join(dir, filepath.Base(path))
		}
	}

	if err := os.MkdirAll(filepath.Dir(realPath), 0o755); err != nil {
		return fmt.Errorf("mkdir %s: %w", filepath.Dir(realPath), err)
	}
	f, err := os.CreateTemp(filepath.Dir(realPath), ".tmp-"+filepath.Base(realPath))
	if err != nil {
		return fmt.Errorf("create temp: %w", err)
	}
	tmpName := f.Name()
	if _, err := f.Write(data); err != nil {
		f.Close()
		os.Remove(tmpName)
		return fmt.Errorf("write temp: %w", err)
	}
	if err := f.Chmod(perm); err != nil {
		f.Close()
		os.Remove(tmpName)
		return fmt.Errorf("chmod temp: %w", err)
	}
	f.Close()
	return os.Rename(tmpName, realPath)
}

func readManifest(path string) (*Manifest, error) {
	data, err := os.ReadFile(path)
	if err != nil {
		return nil, fmt.Errorf("read manifest: %w", err)
	}
	var m Manifest
	if err := json.Unmarshal(data, &m); err != nil {
		return nil, fmt.Errorf("parse manifest: %w", err)
	}
	if m.Version == 0 {
		m.Version = 1
	}
	return &m, nil
}

// defaultIndent is used for new files and when existing formatting can't be detected.
const defaultIndent = "  "

// detectIndent returns the indentation unit of an existing JSON document. Callers
// hardcoding two spaces made every mutation rewrite files that are indented
// differently (dotfiles runs biome, which indents JSON with tabs), burying a
// one-line change in a whole-file diff.
func detectIndent(data []byte) string {
	nl := bytes.IndexByte(data, '\n')
	if nl < 0 {
		return defaultIndent
	}
	rest := data[nl+1:]
	n := 0
	for n < len(rest) && (rest[n] == ' ' || rest[n] == '\t') {
		n++
	}
	if n == 0 {
		return defaultIndent
	}
	return string(rest[:n])
}

// fileIndent detects the indentation of the file at path, falling back to
// defaultIndent when it is absent or unreadable.
func fileIndent(path string) string {
	data, err := os.ReadFile(path)
	if err != nil {
		return defaultIndent
	}
	return detectIndent(data)
}

// writeManifest serializes the manifest with deterministic formatting, preserving
// the file's existing indentation. Output is idempotent: writing the same data
// twice produces identical bytes.
func writeManifest(path string, m *Manifest) error {
	data, err := json.MarshalIndent(m, "", fileIndent(path))
	if err != nil {
		return fmt.Errorf("encode manifest: %w", err)
	}
	data = append(data, '\n')
	return atomicWriteFile(path, data, 0o644)
}

func readLock(path string) (*LockFile, error) {
	data, err := os.ReadFile(path)
	if err != nil {
		if os.IsNotExist(err) {
			return &LockFile{Version: 1, Skills: make(map[string]LockSkill)}, nil
		}
		return nil, fmt.Errorf("read lock: %w", err)
	}
	var l LockFile
	if err := json.Unmarshal(data, &l); err != nil {
		return nil, fmt.Errorf("parse lock: %w", err)
	}
	if l.Skills == nil {
		l.Skills = make(map[string]LockSkill)
	}
	return &l, nil
}

// writeLock mirrors writeManifest: preserve the file's existing indentation and
// emit a trailing newline, so a single entry change does not reformat the whole
// lock or trip POSIX text-file conventions.
func writeLock(path string, l *LockFile) error {
	data, err := json.MarshalIndent(l, "", fileIndent(path))
	if err != nil {
		return fmt.Errorf("encode lock: %w", err)
	}
	data = append(data, '\n')
	return atomicWriteFile(path, data, 0o644)
}

// validateSkillName checks that a skill name is safe to use as a directory name.
func validateSkillName(name string) error {
	if name == "" {
		return fmt.Errorf("skill name is required")
	}
	if name == "." || name == ".." {
		return fmt.Errorf("invalid skill name %q", name)
	}
	if strings.Contains(name, "/") || strings.Contains(name, "\\") || strings.Contains(name, "\x00") {
		return fmt.Errorf("skill name %q contains invalid characters", name)
	}
	return nil
}

// computeSourceHash computes a deterministic hash of a source entry configuration.
// Used to detect changes in source configuration (type, path, files map).
func computeSourceHash(src SourceEntry) string {
	h := sha256.New()
	h.Write([]byte(src.Type))
	h.Write([]byte{0})
	h.Write([]byte(src.Path))
	h.Write([]byte{0})
	if len(src.Files) > 0 {
		keys := make([]string, 0, len(src.Files))
		for k := range src.Files {
			keys = append(keys, k)
		}
		sort.Strings(keys)
		for _, k := range keys {
			h.Write([]byte(k))
			h.Write([]byte{0})
			h.Write([]byte(src.Files[k]))
			h.Write([]byte{0})
		}
	}
	return hex.EncodeToString(h.Sum(nil)[:6])
}