@pi-in-go/pigpen-acp 0.1.0

package/extensions/acp/cmd/pig-acp/internal/acp/startup.go

@@ -0,0 +1,156 @@
+package acp
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+	"time"
+)
+
+var leadingV = regexp.MustCompile(`^[vV]`)
+
+// pigVersionHeader is `pig --version`, or "" when the executable does not answer.
+func pigVersionHeader(piCommand string) string {
+	if piCommand == "" {
+		piCommand = "pig"
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, piCommand, "--version")
+	out, err := cmd.Output()
+	text := jsTrim(string(out))
+	if text == "" && err != nil {
+		return ""
+	}
+	if text == "" {
+		if ee, ok := err.(*exec.ExitError); ok {
+			text = jsTrim(string(ee.Stderr))
+		}
+	}
+	return leadingV.ReplaceAllString(text, "")
+}
+
+func readDirNames(dir string) []string {
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return nil
+	}
+	names := make([]string, 0, len(entries))
+	for _, e := range entries {
+		names = append(names, e.Name())
+	}
+	sort.Strings(names)
+	return names
+}
+
+func isDirPath(p string) (isDir, isFile, ok bool) {
+	st, err := os.Stat(p)
+	if err != nil {
+		return false, false, false
+	}
+	return st.IsDir(), st.Mode().IsRegular(), true
+}
+
+func skillsFromRoot(root string) []string {
+	var items []string
+	for _, e := range readDirNames(root) {
+		p := filepath.Join(root, e)
+		if _, isFile, ok := isDirPath(p); ok && isFile && strings.HasSuffix(strings.ToLower(e), ".md") {
+			items = append(items, p)
+		}
+	}
+	stack := []string{root}
+	for len(stack) > 0 {
+		dir := stack[len(stack)-1]
+		stack = stack[:len(stack)-1]
+		for _, name := range readDirNames(dir) {
+			if name == "node_modules" || name == ".git" {
+				continue
+			}
+			p := filepath.Join(dir, name)
+			isDir, isFile, ok := isDirPath(p)
+			if !ok {
+				continue
+			}
+			if isDir {
+				stack = append(stack, p)
+			} else if isFile && name == "SKILL.md" {
+				items = append(items, p)
+			}
+		}
+	}
+	return items
+}
+
+// BuildStartupInfo builds the markdown "startup info" block (the original's buildStartupInfo,
+// without its npm update notice: see PORT.md, gap A18).
+func BuildStartupInfo(cwd, piCommand string) string {
+	var md []string
+	if v := pigVersionHeader(piCommand); v != "" {
+		md = append(md, "pig v"+v, "---", "")
+	}
+	addSection := func(title string, items []string) {
+		var cleaned []string
+		for _, s := range items {
+			if s = jsTrim(s); s != "" {
+				cleaned = append(cleaned, s)
+			}
+		}
+		if len(cleaned) == 0 {
+			return
+		}
+		md = append(md, "## "+title)
+		for _, item := range cleaned {
+			md = append(md, "- "+item)
+		}
+		md = append(md, "")
+	}
+
+	var context []string
+	contextPath := filepath.Join(cwd, "AGENTS.md")
+	if _, err := os.Stat(contextPath); err == nil {
+		context = append(context, contextPath)
+	}
+	addSection("Context", context)
+
+	var skills []string
+	skills = append(skills, skillsFromRoot(filepath.Join(AgentDir(), "skills"))...)
+	skills = append(skills, skillsFromRoot(filepath.Join(userHome(), ".agents", "skills"))...)
+	skills = append(skills, skillsFromRoot(filepath.Join(cwd, ProjectDirName(), "skills"))...)
+	addSection("Skills", skills)
+
+	var prompts []string
+	for _, f := range readDirNames(filepath.Join(AgentDir(), "prompts")) {
+		if strings.HasSuffix(f, ".md") {
+			prompts = append(prompts, "/"+strings.TrimSuffix(f, ".md"))
+		}
+	}
+	addSection("Prompts", prompts)
+
+	var exts []string
+	extDir := filepath.Join(AgentDir(), "extensions")
+	for _, f := range readDirNames(extDir) {
+		if strings.HasSuffix(f, ".ts") || strings.HasSuffix(f, ".js") {
+			exts = append(exts, filepath.Join(extDir, f))
+		}
+	}
+	for _, sp := range []string{filepath.Join(AgentDir(), "settings.json"), filepath.Join(cwd, ProjectDirName(), "settings.json")} {
+		settings := readJSONObject(sp)
+		pkgs, _ := settings["packages"].([]any)
+		for _, p := range pkgs {
+			s := jsString(p)
+			if strings.HasPrefix(s, "npm:") {
+				exts = append(exts, s+"\n  - index.ts")
+			} else {
+				exts = append(exts, s)
+			}
+		}
+	}
+	addSection("Extensions", exts)
+
+	return jsTrim(strings.Join(md, "\n")) + "\n"
+}

package/extensions/acp/cmd/pig-acp/internal/acp/store.go

@@ -0,0 +1,118 @@
+package acp
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+)
+
+// StoredSession is one entry of the adapter's session map.
+type StoredSession struct {
+	SessionID   string `json:"sessionId"`
+	Cwd         string `json:"cwd"`
+	SessionFile string `json:"sessionFile"`
+	UpdatedAt   string `json:"updatedAt"`
+}
+
+// Store maps ACP session ids to pi session files (SessionStore of the original).
+type Store interface {
+	Get(sessionID string) *StoredSession
+	Upsert(entry StoredSession)
+	Delete(sessionID string)
+}
+
+type sessionMapFile struct {
+	Version  int                      `json:"version"`
+	Sessions map[string]StoredSession `json:"sessions"`
+}
+
+// FileStore is a Store kept in one JSON file. Every operation reads the file again, so two
+// adapter processes (two editor windows) see each other's entries.
+type FileStore struct {
+	path string
+	mu   sync.Mutex
+}
+
+// NewFileStore returns a store at path ("" = the default location under PIG_HOME).
+func NewFileStore(path string) *FileStore {
+	if path == "" {
+		path = SessionMapPath()
+	}
+	return &FileStore{path: path}
+}
+
+func (s *FileStore) load() sessionMapFile {
+	empty := sessionMapFile{Version: 1, Sessions: map[string]StoredSession{}}
+	raw, err := os.ReadFile(s.path)
+	if err != nil {
+		return empty
+	}
+	var f struct {
+		Version  int                        `json:"version"`
+		Sessions map[string]json.RawMessage `json:"sessions"`
+	}
+	if json.Unmarshal(raw, &f) != nil || f.Version != 1 || f.Sessions == nil {
+		return empty
+	}
+	for id, r := range f.Sessions {
+		var e StoredSession
+		if json.Unmarshal(r, &e) == nil {
+			empty.Sessions[id] = e
+		}
+	}
+	return empty
+}
+
+func (s *FileStore) save(f sessionMapFile) {
+	if err := os.MkdirAll(filepath.Dir(s.path), 0o755); err != nil {
+		return
+	}
+	b, err := json.MarshalIndent(f, "", "  ")
+	if err != nil {
+		return
+	}
+	// Write to a sibling and rename, so a second adapter never reads half a file.
+	tmp := s.path + ".tmp"
+	if os.WriteFile(tmp, append(b, '\n'), 0o600) == nil {
+		if os.Rename(tmp, s.path) != nil {
+			_ = os.WriteFile(s.path, append(b, '\n'), 0o600)
+			_ = os.Remove(tmp)
+		}
+	}
+}
+
+// Get returns the entry for sessionID, or nil.
+func (s *FileStore) Get(sessionID string) *StoredSession {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if e, ok := s.load().Sessions[sessionID]; ok {
+		return &e
+	}
+	return nil
+}
+
+// Upsert records or refreshes an entry.
+func (s *FileStore) Upsert(entry StoredSession) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	f := s.load()
+	f.Sessions[entry.SessionID] = StoredSession{
+		SessionID: entry.SessionID, Cwd: entry.Cwd, SessionFile: entry.SessionFile,
+		UpdatedAt: time.Now().UTC().Format("2006-01-02T15:04:05.000Z"),
+	}
+	s.save(f)
+}
+
+// Delete removes an entry.
+func (s *FileStore) Delete(sessionID string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	f := s.load()
+	if _, ok := f.Sessions[sessionID]; !ok {
+		return
+	}
+	delete(f.Sessions, sessionID)
+	s.save(f)
+}