orch-code 0.1.1

package/internal/runtime/lock.go

@@ -0,0 +1,150 @@
+package runtime
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"syscall"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/config"
+)
+
+const lockFileName = "lock"
+
+type LockManager struct {
+	repoRoot   string
+	lockPath   string
+	staleAfter time.Duration
+}
+
+type LockFile struct {
+	PID       int       `json:"pid"`
+	RunID     string    `json:"run_id,omitempty"`
+	CreatedAt time.Time `json:"created_at"`
+}
+
+func NewLockManager(repoRoot string, staleAfter time.Duration) *LockManager {
+	if staleAfter <= 0 {
+		staleAfter = time.Hour
+	}
+	return &LockManager{
+		repoRoot:   repoRoot,
+		lockPath:   filepath.Join(repoRoot, config.OrchDir, lockFileName),
+		staleAfter: staleAfter,
+	}
+}
+
+func (m *LockManager) Acquire(runID string) (func() error, error) {
+	if err := config.EnsureOrchDir(m.repoRoot); err != nil {
+		return nil, err
+	}
+
+	for attempt := 0; attempt < 2; attempt++ {
+		owner := LockFile{
+			PID:       os.Getpid(),
+			RunID:     runID,
+			CreatedAt: time.Now().UTC(),
+		}
+		if err := m.create(owner); err == nil {
+			return func() error {
+				return m.Release(owner)
+			}, nil
+		} else if !os.IsExist(err) {
+			return nil, err
+		}
+
+		existing, readErr := m.readLock()
+		if readErr != nil {
+			if removeErr := os.Remove(m.lockPath); removeErr != nil && !os.IsNotExist(removeErr) {
+				return nil, fmt.Errorf("lock exists and is unreadable: %w", readErr)
+			}
+			continue
+		}
+
+		if !m.isStale(existing) {
+			return nil, fmt.Errorf("repository locked by pid=%d run=%s", existing.PID, existing.RunID)
+		}
+
+		if err := os.Remove(m.lockPath); err != nil && !os.IsNotExist(err) {
+			return nil, fmt.Errorf("failed to remove stale lock: %w", err)
+		}
+	}
+
+	return nil, fmt.Errorf("failed to acquire repository lock")
+}
+
+func (m *LockManager) Release(owner LockFile) error {
+	existing, err := m.readLock()
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+		return err
+	}
+
+	if existing.PID != owner.PID || !existing.CreatedAt.Equal(owner.CreatedAt) {
+		return nil
+	}
+
+	if err := os.Remove(m.lockPath); err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("failed to release lock: %w", err)
+	}
+
+	return nil
+}
+
+func (m *LockManager) create(lock LockFile) error {
+	f, err := os.OpenFile(m.lockPath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o644)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	enc := json.NewEncoder(f)
+	if err := enc.Encode(lock); err != nil {
+		return fmt.Errorf("failed to encode lock file: %w", err)
+	}
+
+	return nil
+}
+
+func (m *LockManager) readLock() (LockFile, error) {
+	var lock LockFile
+	data, err := os.ReadFile(m.lockPath)
+	if err != nil {
+		return lock, err
+	}
+	if err := json.Unmarshal(data, &lock); err != nil {
+		return lock, err
+	}
+	return lock, nil
+}
+
+func (m *LockManager) isStale(lock LockFile) bool {
+	if lock.PID <= 0 {
+		return true
+	}
+
+	age := time.Since(lock.CreatedAt)
+	if age > m.staleAfter {
+		return true
+	}
+
+	return !processAlive(lock.PID)
+}
+
+func processAlive(pid int) bool {
+	if pid == os.Getpid() {
+		return true
+	}
+	process, err := os.FindProcess(pid)
+	if err != nil {
+		return false
+	}
+	if err := process.Signal(syscall.Signal(0)); err != nil {
+		return false
+	}
+	return true
+}

package/internal/runtime/lock_test.go

@@ -0,0 +1,57 @@
+package runtime
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/config"
+)
+
+func TestLockAcquireAndRelease(t *testing.T) {
+	repoRoot := t.TempDir()
+	if err := config.EnsureOrchDir(repoRoot); err != nil {
+		t.Fatalf("ensure orch dir: %v", err)
+	}
+
+	m := NewLockManager(repoRoot, time.Minute)
+	release, err := m.Acquire("run-1")
+	if err != nil {
+		t.Fatalf("acquire first lock: %v", err)
+	}
+
+	if _, err := m.Acquire("run-2"); err == nil {
+		t.Fatalf("expected second acquire to fail while lock is held")
+	}
+
+	if err := release(); err != nil {
+		t.Fatalf("release lock: %v", err)
+	}
+
+	if _, err := m.Acquire("run-3"); err != nil {
+		t.Fatalf("expected acquire to succeed after release: %v", err)
+	}
+}
+
+func TestLockRecoversStaleLock(t *testing.T) {
+	repoRoot := t.TempDir()
+	if err := config.EnsureOrchDir(repoRoot); err != nil {
+		t.Fatalf("ensure orch dir: %v", err)
+	}
+
+	lockPath := filepath.Join(repoRoot, config.OrchDir, lockFileName)
+	stale := `{"pid":999999,"run_id":"old","created_at":"2000-01-01T00:00:00Z"}`
+	if err := os.WriteFile(lockPath, []byte(stale), 0o644); err != nil {
+		t.Fatalf("write stale lock: %v", err)
+	}
+
+	m := NewLockManager(repoRoot, time.Second)
+	release, err := m.Acquire("run-fresh")
+	if err != nil {
+		t.Fatalf("acquire should recover stale lock: %v", err)
+	}
+	if err := release(); err != nil {
+		t.Fatalf("release lock: %v", err)
+	}
+}

package/internal/session/compaction.go

@@ -0,0 +1,260 @@
+package session
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"regexp"
+	"sort"
+	"strings"
+
+	"github.com/furkanbeydemir/orch/internal/storage"
+)
+
+type TokenBudget struct {
+	ContextLimit   int
+	ReservedOutput int
+	SafetyMargin   float64
+}
+
+func (b TokenBudget) UsableInput() int {
+	usable := b.ContextLimit - b.ReservedOutput
+	if usable < 0 {
+		return 0
+	}
+	return usable
+}
+
+func ResolveBudget(modelID string) TokenBudget {
+	model := strings.ToLower(strings.TrimSpace(modelID))
+	switch {
+	case strings.Contains(model, "gpt-5"):
+		return TokenBudget{ContextLimit: 200000, ReservedOutput: 16000, SafetyMargin: 0.12}
+	case strings.Contains(model, "gpt-4"):
+		return TokenBudget{ContextLimit: 128000, ReservedOutput: 12000, SafetyMargin: 0.15}
+	default:
+		return TokenBudget{ContextLimit: 64000, ReservedOutput: 8000, SafetyMargin: 0.18}
+	}
+}
+
+type modelTokenProfile struct {
+	CharPerToken float64
+	BaseOverhead int
+	RoleOverhead int
+	PartOverhead map[string]int
+}
+
+func resolveTokenProfile(modelID string) modelTokenProfile {
+	model := strings.ToLower(strings.TrimSpace(modelID))
+	base := modelTokenProfile{
+		CharPerToken: 4.0,
+		BaseOverhead: 8,
+		RoleOverhead: 2,
+		PartOverhead: map[string]int{
+			"text":       4,
+			"tool":       6,
+			"stage":      5,
+			"compaction": 8,
+			"error":      4,
+			"file":       4,
+		},
+	}
+	if strings.Contains(model, "gpt-5") {
+		base.CharPerToken = 3.7
+		base.BaseOverhead = 10
+	}
+	if strings.Contains(model, "gpt-4") {
+		base.CharPerToken = 3.9
+		base.BaseOverhead = 10
+	}
+	return base
+}
+
+func EstimateTokens(messages []MessageWithParts, modelID string) int {
+	profile := resolveTokenProfile(modelID)
+	totalTokens := 0
+	for _, message := range messages {
+		totalTokens += profile.BaseOverhead
+		totalTokens += profile.RoleOverhead
+		totalTokens += charsToTokens(len(strings.TrimSpace(message.Message.Role)), profile.CharPerToken)
+		totalTokens += charsToTokens(len(strings.TrimSpace(message.Message.Error)), profile.CharPerToken)
+		for _, part := range message.Parts {
+			partType := strings.ToLower(strings.TrimSpace(part.Type))
+			totalTokens += profile.PartOverhead[partType]
+			totalTokens += charsToTokens(len(strings.TrimSpace(part.Payload)), profile.CharPerToken)
+		}
+	}
+	if totalTokens < 0 {
+		return 0
+	}
+	if totalTokens == 0 {
+		return 1
+	}
+	return totalTokens
+}
+
+func charsToTokens(chars int, charPerToken float64) int {
+	if chars <= 0 {
+		return 0
+	}
+	if charPerToken <= 0 {
+		charPerToken = 4.0
+	}
+	return int(math.Ceil(float64(chars) / charPerToken))
+}
+
+func (s *Service) MaybeCompact(sessionID, modelID string) (bool, string, error) {
+	if s == nil || s.store == nil {
+		return false, "", fmt.Errorf("session service is not initialized")
+	}
+
+	messages, err := s.ListMessagesWithParts(sessionID, 500)
+	if err != nil {
+		return false, "", err
+	}
+	if len(messages) == 0 {
+		return false, "", nil
+	}
+
+	budget := ResolveBudget(modelID)
+	estimated := EstimateTokens(messages, modelID)
+	threshold := int(float64(budget.UsableInput()) * (1.0 - budget.SafetyMargin))
+	if threshold < 1 {
+		threshold = 1
+	}
+	if estimated < threshold {
+		return false, "", nil
+	}
+
+	summary := summarizeForCompaction(messages, estimated, budget)
+	summaryPayload, err := json.Marshal(map[string]any{
+		"estimated_tokens": estimated,
+		"usable_input":     budget.UsableInput(),
+		"threshold":        threshold,
+		"safety_margin":    budget.SafetyMargin,
+		"summary":          summary,
+	})
+	if err != nil {
+		return false, "", fmt.Errorf("serialize compaction payload: %w", err)
+	}
+
+	parts := []storage.SessionPart{{Type: "compaction", Payload: string(summaryPayload)}}
+	if _, err := s.AppendMessage(MessageInput{
+		SessionID:    sessionID,
+		Role:         "assistant",
+		FinishReason: "compacted",
+		Text:         summary,
+	}, parts); err != nil {
+		return false, "", err
+	}
+
+	affected, err := s.store.CompactSessionParts(sessionID, 12)
+	if err != nil {
+		return false, "", err
+	}
+	if err := s.store.UpsertSessionSummary(sessionID, summary); err != nil {
+		return false, "", err
+	}
+
+	message := fmt.Sprintf("session compaction applied (tokens=%d, threshold=%d, compacted_parts=%d)", estimated, threshold, affected)
+	return true, message, nil
+}
+
+func summarizeForCompaction(messages []MessageWithParts, estimated int, budget TokenBudget) string {
+	files := collectRelevantPaths(messages, 8)
+	recent := collectRecentTexts(messages, 3, 220)
+
+	lines := []string{
+		"## Goal",
+		"Continue the conversation with reduced context size.",
+		"",
+		"## Instructions",
+		"Preserve user intent, prioritize latest requests, and avoid reprocessing compacted raw outputs.",
+		"",
+		"## Discoveries",
+		fmt.Sprintf("Estimated context tokens reached %d (usable budget %d).", estimated, budget.UsableInput()),
+	}
+	if len(recent) > 0 {
+		lines = append(lines, "Recent non-empty snippets:")
+		for _, snippet := range recent {
+			lines = append(lines, "- "+snippet)
+		}
+	}
+
+	lines = append(lines,
+		"",
+		"## Accomplished",
+		"Older session parts were compacted and replaced with short placeholders.",
+		"",
+		"## Next",
+		"Continue from the latest user request while relying on this summary and recent messages.",
+	)
+
+	if len(files) > 0 {
+		lines = append(lines,
+			"",
+			"## Relevant files/directories",
+		)
+		for _, file := range files {
+			lines = append(lines, "- "+file)
+		}
+	}
+
+	return strings.Join(lines, "\n")
+}
+
+func collectRecentTexts(messages []MessageWithParts, maxCount, maxLen int) []string {
+	if maxCount <= 0 {
+		return []string{}
+	}
+	out := make([]string, 0, maxCount)
+	for i := len(messages) - 1; i >= 0 && len(out) < maxCount; i-- {
+		for _, part := range messages[i].Parts {
+			text := strings.TrimSpace(ExtractTextPart(part))
+			if text == "" {
+				continue
+			}
+			if len(text) > maxLen {
+				text = text[:maxLen] + "..."
+			}
+			out = append(out, text)
+			break
+		}
+	}
+	return out
+}
+
+var pathPattern = regexp.MustCompile(`(?m)([A-Za-z0-9_./-]+\.[A-Za-z0-9]{1,8}|[A-Za-z0-9_./-]+/)`)
+
+func collectRelevantPaths(messages []MessageWithParts, maxCount int) []string {
+	seen := map[string]struct{}{}
+	paths := make([]string, 0, maxCount)
+	for i := len(messages) - 1; i >= 0 && len(paths) < maxCount; i-- {
+		for _, part := range messages[i].Parts {
+			payload := strings.TrimSpace(part.Payload)
+			if payload == "" {
+				continue
+			}
+			matches := pathPattern.FindAllString(payload, -1)
+			for _, match := range matches {
+				candidate := strings.TrimSpace(match)
+				if candidate == "" || strings.HasPrefix(candidate, "http") {
+					continue
+				}
+				if _, ok := seen[candidate]; ok {
+					continue
+				}
+				seen[candidate] = struct{}{}
+				paths = append(paths, candidate)
+				if len(paths) >= maxCount {
+					break
+				}
+			}
+			if len(paths) >= maxCount {
+				break
+			}
+		}
+	}
+	sort.Strings(paths)
+	return paths
+}

package/internal/session/compaction_test.go

@@ -0,0 +1,36 @@
+package session
+
+import (
+	"testing"
+
+	"github.com/furkanbeydemir/orch/internal/storage"
+)
+
+func TestEstimateTokensModelAware(t *testing.T) {
+	messages := []MessageWithParts{{
+		Message: storage.SessionMessage{Role: "assistant"},
+		Parts: []storage.SessionPart{
+			{Type: "text", Payload: `{"text":"hello world"}`},
+			{Type: "stage", Payload: `{"actor":"planner","step":"plan","message":"a"}`},
+		},
+	}}
+
+	gpt5 := EstimateTokens(messages, "gpt-5.3-codex")
+	defaultModel := EstimateTokens(messages, "unknown-model")
+	if gpt5 <= 0 || defaultModel <= 0 {
+		t.Fatalf("expected positive token estimates, got gpt5=%d default=%d", gpt5, defaultModel)
+	}
+	if gpt5 == defaultModel {
+		t.Fatalf("expected model-aware token difference, both=%d", gpt5)
+	}
+}
+
+func TestResolveBudgetSafetyMargin(t *testing.T) {
+	b := ResolveBudget("gpt-5.3-codex")
+	if b.UsableInput() <= 0 {
+		t.Fatalf("expected usable input to be positive")
+	}
+	if b.SafetyMargin <= 0 || b.SafetyMargin >= 1 {
+		t.Fatalf("expected safety margin to be between 0 and 1, got %f", b.SafetyMargin)
+	}
+}

package/internal/session/service.go

@@ -0,0 +1,117 @@
+package session
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/furkanbeydemir/orch/internal/storage"
+)
+
+type Service struct {
+	store *storage.Store
+}
+
+type MessageWithParts struct {
+	Message storage.SessionMessage
+	Parts   []storage.SessionPart
+}
+
+type MessageInput struct {
+	SessionID    string
+	Role         string
+	ParentID     string
+	ProviderID   string
+	ModelID      string
+	FinishReason string
+	Error        string
+	Text         string
+}
+
+func NewService(store *storage.Store) *Service {
+	return &Service{store: store}
+}
+
+func (s *Service) AppendText(input MessageInput) (*MessageWithParts, error) {
+	parts := []storage.SessionPart{}
+	text := strings.TrimSpace(input.Text)
+	if text != "" {
+		payloadBytes, err := json.Marshal(map[string]string{"text": text})
+		if err != nil {
+			return nil, fmt.Errorf("serialize text payload: %w", err)
+		}
+		parts = append(parts, storage.SessionPart{
+			Type:    "text",
+			Payload: string(payloadBytes),
+		})
+	}
+
+	return s.AppendMessage(input, parts)
+}
+
+func (s *Service) AppendMessage(input MessageInput, parts []storage.SessionPart) (*MessageWithParts, error) {
+	if s == nil || s.store == nil {
+		return nil, fmt.Errorf("session service is not initialized")
+	}
+
+	role := strings.ToLower(strings.TrimSpace(input.Role))
+	if role == "" {
+		return nil, fmt.Errorf("message role is required")
+	}
+
+	createdMsg, createdParts, err := s.store.CreateMessageWithParts(storage.SessionMessage{
+		SessionID:    strings.TrimSpace(input.SessionID),
+		Role:         role,
+		ParentID:     strings.TrimSpace(input.ParentID),
+		ProviderID:   strings.TrimSpace(input.ProviderID),
+		ModelID:      strings.TrimSpace(input.ModelID),
+		FinishReason: strings.TrimSpace(input.FinishReason),
+		Error:        strings.TrimSpace(input.Error),
+		CreatedAt:    time.Now().UTC(),
+	}, parts)
+	if err != nil {
+		return nil, err
+	}
+
+	return &MessageWithParts{Message: createdMsg, Parts: createdParts}, nil
+}
+
+func (s *Service) ListMessagesWithParts(sessionID string, limit int) ([]MessageWithParts, error) {
+	if s == nil || s.store == nil {
+		return nil, fmt.Errorf("session service is not initialized")
+	}
+
+	messages, err := s.store.ListSessionMessages(sessionID, limit)
+	if err != nil {
+		return nil, err
+	}
+
+	result := make([]MessageWithParts, 0, len(messages))
+	for _, msg := range messages {
+		parts, partErr := s.store.ListSessionParts(msg.ID)
+		if partErr != nil {
+			return nil, partErr
+		}
+		result = append(result, MessageWithParts{Message: msg, Parts: parts})
+	}
+
+	return result, nil
+}
+
+func ExtractTextPart(part storage.SessionPart) string {
+	if strings.ToLower(strings.TrimSpace(part.Type)) != "text" {
+		return ""
+	}
+	if strings.TrimSpace(part.Payload) == "" {
+		return ""
+	}
+	var payload map[string]any
+	if err := json.Unmarshal([]byte(part.Payload), &payload); err != nil {
+		return strings.TrimSpace(part.Payload)
+	}
+	if text, ok := payload["text"].(string); ok {
+		return strings.TrimSpace(text)
+	}
+	return strings.TrimSpace(part.Payload)
+}