@fatalmistake02/rian 0.0.0-stage → 0.2.1

package/internal/config/config.go

@@ -0,0 +1,189 @@
+// Package config stores local settings with atomic writes and a cross-process
+// lock. Updates always reload the file so two Rian instances do not lose edits.
+package config
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"rian/internal/project"
+)
+
+const Version = 1
+
+type Config struct {
+	Version  int               `json:"version"`
+	Revision uint64            `json:"revision,omitempty"`
+	Projects []project.Project `json:"projects"`
+}
+
+type Store struct {
+	Path string
+	mu   sync.Mutex
+}
+
+func DefaultPath() (string, error) {
+	if dir := os.Getenv("RIAN_CONFIG_HOME"); dir != "" {
+		return filepath.Join(dir, "config.json"), nil
+	}
+	dir, err := os.UserConfigDir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(dir, "rian", "config.json"), nil
+}
+
+func New(path string) *Store { return &Store{Path: path} }
+
+func (s *Store) Load() (Config, error) {
+	data, err := os.ReadFile(s.Path)
+	if errors.Is(err, os.ErrNotExist) {
+		return Config{Version: Version, Projects: []project.Project{}}, nil
+	}
+	if err != nil {
+		return Config{}, fmt.Errorf("read config: %w", err)
+	}
+	var cfg Config
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		return Config{}, fmt.Errorf("invalid config %s (file preserved): %w", s.Path, err)
+	}
+	if cfg.Version != Version {
+		return Config{}, fmt.Errorf("unsupported config version %d (file preserved)", cfg.Version)
+	}
+	if err := validate(cfg); err != nil {
+		return Config{}, fmt.Errorf("invalid config (file preserved): %w", err)
+	}
+	project.Sort(cfg.Projects)
+	return cfg, nil
+}
+
+func validate(cfg Config) error {
+	ids := map[string]bool{}
+	for i, p := range cfg.Projects {
+		if strings.TrimSpace(p.ID) == "" || strings.TrimSpace(p.Name) == "" || !filepath.IsAbs(p.Path) {
+			return fmt.Errorf("project %d needs an ID, name, and absolute path", i+1)
+		}
+		if ids[p.ID] {
+			return fmt.Errorf("duplicate project ID %s", p.ID)
+		}
+		ids[p.ID] = true
+		for _, prior := range cfg.Projects[:i] {
+			if project.SamePath(p.Path, prior.Path) {
+				return fmt.Errorf("directory already belongs to %s", prior.Name)
+			}
+		}
+	}
+	return nil
+}
+
+func (s *Store) Update(change func(*Config) error) (Config, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	dir := filepath.Dir(s.Path)
+	if err := os.MkdirAll(dir, 0700); err != nil {
+		return Config{}, err
+	}
+	lock := s.Path + ".lock"
+	deadline := time.Now().Add(3 * time.Second)
+	for {
+		err := os.Mkdir(lock, 0700)
+		if err == nil {
+			break
+		}
+		if !errors.Is(err, os.ErrExist) {
+			return Config{}, err
+		}
+		if time.Now().After(deadline) {
+			return Config{}, fmt.Errorf("config is locked by another Rian instance; if none is running, remove %s", lock)
+		}
+		time.Sleep(30 * time.Millisecond)
+	}
+	defer os.Remove(lock)
+	cfg, err := s.Load()
+	if err != nil {
+		return Config{}, err
+	}
+	if err := change(&cfg); err != nil {
+		return Config{}, err
+	}
+	cfg.Version = Version
+	cfg.Revision++
+	if err := validate(cfg); err != nil {
+		return Config{}, err
+	}
+	project.Sort(cfg.Projects)
+	data, err := json.MarshalIndent(cfg, "", "  ")
+	if err != nil {
+		return Config{}, err
+	}
+	f, err := os.CreateTemp(dir, ".rian-*.tmp")
+	if err != nil {
+		return Config{}, err
+	}
+	defer os.Remove(f.Name())
+	if err := f.Chmod(0600); err != nil {
+		f.Close()
+		return Config{}, err
+	}
+	if _, err := f.Write(append(data, '\n')); err != nil {
+		f.Close()
+		return Config{}, err
+	}
+	if err := f.Sync(); err != nil {
+		f.Close()
+		return Config{}, err
+	}
+	if err := f.Close(); err != nil {
+		return Config{}, err
+	}
+	if err := os.Rename(f.Name(), s.Path); err != nil {
+		return Config{}, fmt.Errorf("save config: %w", err)
+	}
+	return cfg, nil
+}
+
+func Add(cfg *Config, p project.Project) error {
+	for _, existing := range cfg.Projects {
+		if project.SamePath(existing.Path, p.Path) {
+			return fmt.Errorf("this directory is already saved as %s", existing.Name)
+		}
+	}
+	cfg.Projects = append(cfg.Projects, p)
+	return nil
+}
+
+func Replace(cfg *Config, p project.Project) error {
+	for i := range cfg.Projects {
+		if cfg.Projects[i].ID == p.ID {
+			cfg.Projects[i] = p
+			return nil
+		}
+	}
+	return fmt.Errorf("project was removed by another Rian instance")
+}
+
+func Remove(cfg *Config, id string) error {
+	for i, p := range cfg.Projects {
+		if p.ID == id {
+			cfg.Projects = append(cfg.Projects[:i], cfg.Projects[i+1:]...)
+			return nil
+		}
+	}
+	return fmt.Errorf("project no longer exists")
+}
+
+func Touch(cfg *Config, id string) error {
+	for i := range cfg.Projects {
+		if cfg.Projects[i].ID == id {
+			cfg.Projects[i].LastUsed = time.Now()
+			return nil
+		}
+	}
+	return fmt.Errorf("project no longer exists")
+}

package/internal/config/config_test.go

@@ -0,0 +1,101 @@
+package config
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+	"testing"
+
+	"rian/internal/project"
+)
+
+func TestRoundTripAndRemoval(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "settings", "config.json")
+	store := New(path)
+	cfg, err := store.Load()
+	if err != nil || len(cfg.Projects) != 0 {
+		t.Fatalf("empty load: %+v %v", cfg, err)
+	}
+	p := project.New("My project", dir)
+	p.Commands = map[string]string{"dev": "npm run dev"}
+	p.Tools = map[string]bool{"opencode": false}
+	p.URLs = map[string]string{"local": "http://localhost:3000"}
+	if _, err := store.Update(func(cfg *Config) error { return Add(cfg, p) }); err != nil {
+		t.Fatal(err)
+	}
+	cfg, err = New(path).Load()
+	if err != nil || len(cfg.Projects) != 1 || cfg.Projects[0].Commands["dev"] != "npm run dev" || cfg.Projects[0].ToolEnabled("opencode") {
+		t.Fatalf("round trip: %+v %v", cfg, err)
+	}
+	if _, err := store.Update(func(cfg *Config) error { return Add(cfg, p) }); err == nil {
+		t.Fatal("duplicate directory accepted")
+	}
+	if _, err := store.Update(func(cfg *Config) error { return Touch(cfg, p.ID) }); err != nil {
+		t.Fatal(err)
+	}
+	cfg, _ = store.Load()
+	if cfg.Projects[0].LastUsed.IsZero() {
+		t.Fatal("recent timestamp missing")
+	}
+	if _, err := store.Update(func(cfg *Config) error { return Remove(cfg, p.ID) }); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(dir); err != nil {
+		t.Fatal("removal deleted the actual directory")
+	}
+	cfg, _ = store.Load()
+	if len(cfg.Projects) != 0 {
+		t.Fatal("entry not removed")
+	}
+	files, _ := filepath.Glob(filepath.Join(filepath.Dir(path), ".rian-*.tmp"))
+	if len(files) != 0 {
+		t.Fatalf("left temporary files: %v", files)
+	}
+}
+
+func TestInvalidConfigPreserved(t *testing.T) {
+	for _, data := range []string{"{broken", `{"version":99,"projects":[]}`, `{"version":1,"projects":[{"id":"x","name":"x","path":"relative"}]}`} {
+		t.Run(data, func(t *testing.T) {
+			path := filepath.Join(t.TempDir(), "config.json")
+			if err := os.WriteFile(path, []byte(data), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := New(path).Update(func(*Config) error { return nil }); err == nil {
+				t.Fatal("invalid config accepted")
+			}
+			actual, _ := os.ReadFile(path)
+			if string(actual) != data {
+				t.Fatal("invalid configuration overwritten")
+			}
+		})
+	}
+}
+
+func TestConcurrentStoresDoNotLoseUpdates(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "config.json")
+	var wg sync.WaitGroup
+	errors := make(chan error, 8)
+	for i := range 8 {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			p := project.New(fmt.Sprintf("project-%d", i), filepath.Join(dir, fmt.Sprint(i)))
+			_, err := New(path).Update(func(cfg *Config) error { return Add(cfg, p) })
+			if err != nil {
+				errors <- err
+			}
+		}(i)
+	}
+	wg.Wait()
+	close(errors)
+	for err := range errors {
+		t.Error(err)
+	}
+	cfg, err := New(path).Load()
+	if err != nil || len(cfg.Projects) != 8 {
+		t.Fatalf("lost updates: %d %v", len(cfg.Projects), err)
+	}
+}

package/internal/detect/detect.go

@@ -0,0 +1,252 @@
+// Package detect inspects a handful of files in the project root. It never
+// installs packages, evaluates project files, or walks node_modules.
+package detect
+
+import (
+	"encoding/json"
+	"fmt"
+	"go/parser"
+	"go/token"
+	"io"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+
+	"rian/internal/git"
+	"rian/internal/project"
+	"rian/internal/tools"
+)
+
+type Result struct {
+	Project   project.Project
+	Git       git.Status
+	Available map[string]bool
+	Warnings  []string
+}
+
+type PackageJSON struct {
+	Name            string                     `json:"name"`
+	PackageManager  string                     `json:"packageManager"`
+	Scripts         map[string]string          `json:"scripts"`
+	Dependencies    map[string]json.RawMessage `json:"dependencies"`
+	DevDependencies map[string]json.RawMessage `json:"devDependencies"`
+}
+
+func AvailableTools() map[string]bool {
+	result := map[string]bool{}
+	for _, name := range []string{"code", "opencode", "kilo", "kilocode", "gh", "lazygit", "git", "npm", "pnpm", "yarn", "bun", "go", "cargo", "python", "python3", "flutter", "chatgpt"} {
+		_, err := tools.LookPath(name)
+		result[name] = err == nil
+	}
+	result["kilocode"] = result["kilo"] || result["kilocode"]
+	return result
+}
+
+func Inspect(path string) (Result, error) {
+	canonical, err := project.CanonicalPath(path)
+	if err != nil {
+		return Result{}, err
+	}
+	p := project.New(filepath.Base(canonical), canonical)
+	p.AutoCommands = map[string]string{}
+	result := Result{Project: p, Available: AvailableTools()}
+	exists := func(name string) bool {
+		info, err := os.Stat(filepath.Join(canonical, name))
+		return err == nil && !info.IsDir()
+	}
+	addStack := func(name string) { result.Project.Stack = append(result.Project.Stack, name) }
+	commands := result.Project.AutoCommands
+	if exists("package.json") {
+		var pkg PackageJSON
+		data, err := readSmall(filepath.Join(canonical, "package.json"))
+		if err == nil {
+			err = json.Unmarshal(data, &pkg)
+		}
+		if err != nil {
+			result.Warnings = append(result.Warnings, "Could not read package.json: "+err.Error())
+		} else {
+			addStack("Node.js")
+			manager := PackageManager(pkg.PackageManager, exists)
+			addStack(manager)
+			for name, command := range ScriptCommands(manager, pkg.Scripts) {
+				commands[name] = command
+			}
+			for _, framework := range []struct{ dep, name string }{{"next", "Next.js"}, {"vite", "Vite"}, {"expo", "Expo"}, {"react-native", "React Native"}, {"react", "React"}} {
+				_, prod := pkg.Dependencies[framework.dep]
+				_, dev := pkg.DevDependencies[framework.dep]
+				if prod || dev {
+					addStack(framework.name)
+				}
+			}
+		}
+	}
+	if exists("go.mod") {
+		addStack("Go")
+		defaults(commands, map[string]string{"build": "go build ./...", "test": "go test ./..."})
+		defaults(commands, GoRunCommands(canonical))
+	}
+	if exists("Cargo.toml") {
+		addStack("Rust")
+		defaults(commands, map[string]string{"run": "cargo run", "build": "cargo build", "test": "cargo test", "lint": "cargo clippy"})
+	}
+	if exists("pyproject.toml") || exists("requirements.txt") || exists("setup.py") || exists("Pipfile") {
+		addStack("Python")
+		interpreter := "python3"
+		if runtime.GOOS == "windows" {
+			interpreter = "python"
+		}
+		defaults(commands, map[string]string{"test": interpreter + " -m pytest"})
+		if exists("manage.py") {
+			defaults(commands, map[string]string{"dev": interpreter + " manage.py runserver"})
+		}
+		if exists("main.py") {
+			defaults(commands, map[string]string{"run": interpreter + " main.py"})
+		}
+	}
+	if exists("pubspec.yaml") {
+		data, _ := readSmall(filepath.Join(canonical, "pubspec.yaml"))
+		if strings.Contains(string(data), "sdk: flutter") {
+			addStack("Flutter")
+			defaults(commands, map[string]string{"run": "flutter run", "build": "flutter build bundle", "test": "flutter test", "lint": "flutter analyze"})
+		}
+	}
+	result.Git = git.Inspect(canonical)
+	return result, nil
+}
+
+func readSmall(path string) ([]byte, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	data, err := io.ReadAll(io.LimitReader(f, 2*1024*1024+1))
+	if len(data) > 2*1024*1024 {
+		return nil, fmt.Errorf("file is larger than 2 MB")
+	}
+	return data, err
+}
+
+func defaults(commands, values map[string]string) {
+	for key, value := range values {
+		if _, exists := commands[key]; !exists {
+			commands[key] = value
+		}
+	}
+}
+
+func PackageManager(declared string, exists func(string) bool) string {
+	manager := strings.SplitN(declared, "@", 2)[0]
+	if manager == "npm" || manager == "pnpm" || manager == "yarn" || manager == "bun" {
+		return manager
+	}
+	for _, candidate := range []struct {
+		name  string
+		files []string
+	}{{"bun", []string{"bun.lock", "bun.lockb"}}, {"pnpm", []string{"pnpm-lock.yaml"}}, {"yarn", []string{"yarn.lock"}}} {
+		for _, file := range candidate.files {
+			if exists(file) {
+				return candidate.name
+			}
+		}
+	}
+	return "npm"
+}
+
+func ScriptCommands(manager string, scripts map[string]string) map[string]string {
+	result := map[string]string{}
+	for name := range scripts {
+		// npm script names outside this portable set can be added as a custom
+		// command. Never interpolate shell metacharacters from a script name.
+		if name == "" {
+			continue
+		}
+		safe := true
+		for _, r := range name {
+			if !(r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' || r >= '0' && r <= '9' || strings.ContainsRune("_:-.", r)) {
+				safe = false
+				break
+			}
+		}
+		if safe {
+			result[name] = manager + " run " + name
+		}
+	}
+	return result
+}
+
+func CommandNames(commands map[string]string) []string {
+	var names []string
+	for name := range commands {
+		names = append(names, name)
+	}
+	order := map[string]int{"dev": 1, "run": 2, "start": 3, "build": 4, "test": 5, "lint": 6, "typecheck": 7}
+	sort.Slice(names, func(i, j int) bool {
+		a, b := order[names[i]], order[names[j]]
+		if a == 0 {
+			a = 100
+		}
+		if b == 0 {
+			b = 100
+		}
+		if a != b {
+			return a < b
+		}
+		return names[i] < names[j]
+	})
+	return names
+}
+
+// Go repositories often keep their executable under cmd/ and their root is a
+// library. Inspect package clauses so the suggested run command is usable.
+func GoRunCommands(root string) map[string]string {
+	result := map[string]string{}
+	if hasMainPackage(root) {
+		result["run"] = "go run ."
+		return result
+	}
+	entries, _ := os.ReadDir(filepath.Join(root, "cmd"))
+	var runnable []string
+	for i, entry := range entries {
+		if i >= 64 {
+			break
+		}
+		if entry.IsDir() && hasMainPackage(filepath.Join(root, "cmd", entry.Name())) {
+			// Only construct a shell command from portable directory names.
+			if _, safe := ScriptCommands("go", map[string]string{entry.Name(): ""})[entry.Name()]; safe {
+				runnable = append(runnable, entry.Name())
+			}
+		}
+	}
+	for _, name := range runnable {
+		result["run:"+name] = "go run ./cmd/" + name
+	}
+	if len(runnable) == 1 {
+		result["run"] = result["run:"+runnable[0]]
+		delete(result, "run:"+runnable[0])
+	}
+	return result
+}
+
+func hasMainPackage(dir string) bool {
+	entries, _ := os.ReadDir(dir)
+	for i, entry := range entries {
+		if i >= 256 {
+			break
+		}
+		if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".go") || strings.HasSuffix(entry.Name(), "_test.go") {
+			continue
+		}
+		data, err := readSmall(filepath.Join(dir, entry.Name()))
+		if err != nil {
+			continue
+		}
+		file, err := parser.ParseFile(token.NewFileSet(), entry.Name(), data, parser.PackageClauseOnly)
+		if err == nil && file.Name.Name == "main" {
+			return true
+		}
+	}
+	return false
+}

package/internal/detect/detect_test.go

@@ -0,0 +1,86 @@
+package detect
+
+import (
+	"os"
+	"path/filepath"
+	"slices"
+	"testing"
+)
+
+func TestInspectStacksAndCommands(t *testing.T) {
+	tests := []struct {
+		name           string
+		files          map[string]string
+		stack          []string
+		command, value string
+	}{
+		{"next-pnpm", map[string]string{"package.json": `{"scripts":{"dev":"next dev","test":"vitest"},"dependencies":{"next":"15"}}`, "pnpm-lock.yaml": ""}, []string{"Node.js", "pnpm", "Next.js"}, "dev", "pnpm run dev"},
+		{"bun-expo", map[string]string{"package.json": `{"packageManager":"bun@1.2","scripts":{"start":"expo start"},"dependencies":{"expo":"1","react-native":"1"}}`}, []string{"Node.js", "bun", "Expo", "React Native"}, "start", "bun run start"},
+		{"go", map[string]string{"go.mod": "module example.test\n"}, []string{"Go"}, "test", "go test ./..."},
+		{"rust", map[string]string{"Cargo.toml": "[package]\n"}, []string{"Rust"}, "build", "cargo build"},
+		{"python", map[string]string{"requirements.txt": "pytest", "main.py": ""}, []string{"Python"}, "run", ""},
+		{"flutter", map[string]string{"pubspec.yaml": "dependencies:\n  flutter:\n    sdk: flutter\n"}, []string{"Flutter"}, "test", "flutter test"},
+		{"vite-yarn", map[string]string{"package.json": `{"scripts":{"build":"vite build"},"devDependencies":{"vite":"6"}}`, "yarn.lock": ""}, []string{"Node.js", "yarn", "Vite"}, "build", "yarn run build"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dir := t.TempDir()
+			for name, data := range tt.files {
+				if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			result, err := Inspect(dir)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, stack := range tt.stack {
+				if !slices.Contains(result.Project.Stack, stack) {
+					t.Errorf("missing %s in %v", stack, result.Project.Stack)
+				}
+			}
+			command := result.Project.AutoCommands[tt.command]
+			if command == "" || tt.value != "" && command != tt.value {
+				t.Fatalf("command: %q, want %q", command, tt.value)
+			}
+		})
+	}
+}
+
+func TestInvalidFilesAndScriptNames(t *testing.T) {
+	dir := t.TempDir()
+	os.WriteFile(filepath.Join(dir, "package.json"), []byte("{broken"), 0600)
+	result, err := Inspect(dir)
+	if err != nil || len(result.Warnings) == 0 {
+		t.Fatalf("malformed manifest must be nonfatal: %+v %v", result, err)
+	}
+	commands := ScriptCommands("npm", map[string]string{"test:unit": "vitest", "dev && bad": "ignored", "": "ignored", "lint": "eslint"})
+	if len(commands) != 2 || commands["test:unit"] != "npm run test:unit" {
+		t.Fatalf("unsafe or missing scripts: %v", commands)
+	}
+	if actual := PackageManager("yarn@4", func(string) bool { return true }); actual != "yarn" {
+		t.Fatalf("declared manager should win: %s", actual)
+	}
+	if actual := PackageManager("", func(s string) bool { return s == "bun.lockb" }); actual != "bun" {
+		t.Fatal(actual)
+	}
+	if _, err := Inspect(filepath.Join(dir, "missing")); err == nil {
+		t.Fatal("missing directory accepted")
+	}
+}
+
+func TestGoRunUsesExecutableDirectory(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.MkdirAll(filepath.Join(dir, "cmd", "server"), 0700); err != nil {
+		t.Fatal(err)
+	}
+	os.WriteFile(filepath.Join(dir, "library.go"), []byte("package server\n"), 0600)
+	os.WriteFile(filepath.Join(dir, "cmd", "server", "main.go"), []byte("package main\nfunc main() {}\n"), 0600)
+	if commands := GoRunCommands(dir); commands["run"] != "go run ./cmd/server" || len(commands) != 1 {
+		t.Fatalf("bad cmd/ detection: %v", commands)
+	}
+	os.WriteFile(filepath.Join(dir, "main.go"), []byte("package main\n"), 0600)
+	if commands := GoRunCommands(dir); commands["run"] != "go run ." {
+		t.Fatalf("bad root detection: %v", commands)
+	}
+}