@fatalmistake02/rian 0.0.0-stage → 0.2.1

package/internal/project/project.go

@@ -0,0 +1,180 @@
+// Package project contains the persistent project model and lookup rules.
+package project
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+	"time"
+	"unicode"
+)
+
+type Project struct {
+	ID           string            `json:"id"`
+	Name         string            `json:"name"`
+	Path         string            `json:"path"`
+	Favorite     bool              `json:"favorite,omitempty"`
+	GitHub       string            `json:"github,omitempty"`
+	Tools        map[string]bool   `json:"tools,omitempty"`
+	Commands     map[string]string `json:"commands,omitempty"`
+	AutoCommands map[string]string `json:"auto_commands,omitempty"`
+	Stack        []string          `json:"stack,omitempty"`
+	URLs         map[string]string `json:"urls,omitempty"`
+	AddedAt      time.Time         `json:"added_at"`
+	LastUsed     time.Time         `json:"last_used,omitempty"`
+}
+
+func New(name, path string) Project {
+	b := make([]byte, 8)
+	if _, err := rand.Read(b); err != nil {
+		// A timestamp remains sufficient for a local entry if the OS RNG fails.
+		return Project{ID: fmt.Sprintf("%x", time.Now().UnixNano()), Name: name, Path: path, AddedAt: time.Now()}
+	}
+	return Project{ID: hex.EncodeToString(b), Name: name, Path: path, AddedAt: time.Now()}
+}
+
+func (p Project) ToolEnabled(name string) bool {
+	enabled, set := p.Tools[name]
+	return !set || enabled
+}
+
+func (p Project) AllCommands() map[string]string {
+	result := make(map[string]string, len(p.AutoCommands)+len(p.Commands))
+	for name, command := range p.AutoCommands {
+		result[name] = command
+	}
+	for name, command := range p.Commands {
+		result[name] = command
+	}
+	return result
+}
+
+func CanonicalPath(path string) (string, error) {
+	path = strings.TrimSpace(path)
+	if path == "~" || strings.HasPrefix(path, "~/") || strings.HasPrefix(path, "~\\") {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return "", err
+		}
+		path = filepath.Join(home, strings.TrimLeft(strings.TrimPrefix(path, "~"), "/\\"))
+	}
+	if path == "" {
+		return "", fmt.Errorf("enter a project directory")
+	}
+	abs, err := filepath.Abs(path)
+	if err != nil {
+		return "", err
+	}
+	info, err := os.Stat(abs)
+	if err != nil {
+		return "", fmt.Errorf("directory is unavailable: %w", err)
+	}
+	if !info.IsDir() {
+		return "", fmt.Errorf("%s is not a directory", abs)
+	}
+	resolved, err := filepath.EvalSymlinks(abs)
+	if err != nil {
+		return "", err
+	}
+	return filepath.Clean(resolved), nil
+}
+
+func SamePath(a, b string) bool {
+	a, b = filepath.Clean(a), filepath.Clean(b)
+	if runtime.GOOS == "windows" {
+		return strings.EqualFold(a, b)
+	}
+	return a == b
+}
+
+func Sort(projects []Project) {
+	sort.SliceStable(projects, func(i, j int) bool {
+		a, b := projects[i], projects[j]
+		if a.Favorite != b.Favorite {
+			return a.Favorite
+		}
+		if !a.LastUsed.Equal(b.LastUsed) {
+			return a.LastUsed.After(b.LastUsed)
+		}
+		return strings.ToLower(a.Name) < strings.ToLower(b.Name)
+	})
+}
+
+// Score performs Unicode-aware subsequence matching. Consecutive letters and
+// word boundaries rank ahead of scattered matches. A negative score is no match.
+func Score(query, value string) int {
+	q := []rune(strings.ToLower(strings.TrimSpace(query)))
+	v := []rune(strings.ToLower(value))
+	if len(q) == 0 {
+		return 0
+	}
+	qi, score, previous := 0, 0, -2
+	for i, r := range v {
+		if r != q[qi] {
+			continue
+		}
+		score += 10
+		if i == previous+1 {
+			score += 12
+		}
+		if i == 0 || !unicode.IsLetter(v[i-1]) && !unicode.IsDigit(v[i-1]) {
+			score += 8
+		}
+		score -= i - previous - 1
+		previous = i
+		qi++
+		if qi == len(q) {
+			return max(0, score-(len(v)-len(q))/3)
+		}
+	}
+	return -1
+}
+
+func Filter(projects []Project, query string) []Project {
+	result := make([]Project, 0, len(projects))
+	pathQuery := strings.ToLower(strings.TrimSpace(query))
+	for _, p := range projects {
+		if Score(query, p.Name) >= 0 || strings.Contains(strings.ToLower(p.Path), pathQuery) {
+			result = append(result, p)
+		}
+	}
+	if strings.TrimSpace(query) != "" {
+		sort.SliceStable(result, func(i, j int) bool { return Score(query, result[i].Name) > Score(query, result[j].Name) })
+	}
+	return result
+}
+
+func Lookup(projects []Project, query string) (Project, error) {
+	if strings.TrimSpace(query) == "" {
+		return Project{}, fmt.Errorf("enter a project name or ID")
+	}
+	var exact []Project
+	for _, p := range projects {
+		if p.ID == query {
+			return p, nil
+		}
+		if strings.EqualFold(p.Name, query) {
+			exact = append(exact, p)
+		}
+	}
+	matches := exact
+	if len(matches) == 0 {
+		matches = Filter(projects, query)
+	}
+	if len(matches) == 1 {
+		return matches[0], nil
+	}
+	if len(matches) == 0 {
+		return Project{}, fmt.Errorf("no project matches %q", query)
+	}
+	var names []string
+	for _, p := range matches {
+		names = append(names, fmt.Sprintf("  %s  [%s]  %s", p.Name, p.ID, p.Path))
+	}
+	return Project{}, fmt.Errorf("%q is ambiguous; use a project ID:\n%s", query, strings.Join(names, "\n"))
+}

package/internal/project/project_test.go

@@ -0,0 +1,71 @@
+package project
+
+import (
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestFuzzyLookup(t *testing.T) {
+	projects := []Project{{ID: "one", Name: "Cardly", Path: "/dev/cardly"}, {ID: "two", Name: "Card Scanner Test", Path: "/dev/scanner"}, {ID: "three", Name: "Drift", Path: "/dev/drift"}}
+	if matches := Filter(projects, "car"); len(matches) != 2 || matches[0].Name != "Cardly" {
+		t.Fatalf("unexpected matches: %+v", matches)
+	}
+	for _, query := range []string{"Cardly", "CARDLY", "one", "cdly"} {
+		p, err := Lookup(projects, query)
+		if err != nil || p.ID != "one" {
+			t.Fatalf("%q: %+v %v", query, p, err)
+		}
+	}
+	if _, err := Lookup(projects, "car"); err == nil || !strings.Contains(err.Error(), "ambiguous") || !strings.Contains(err.Error(), "two") {
+		t.Fatalf("expected ambiguity with IDs, got %v", err)
+	}
+	if _, err := Lookup(projects, "xyz"); err == nil {
+		t.Fatal("expected no match")
+	}
+	if _, err := Lookup(projects[:1], ""); err == nil {
+		t.Fatal("empty query must not select a project")
+	}
+	if Score("ré", "Résumé") < 0 || Score("ab", "a"+strings.Repeat("x", 500)+"b") < 0 {
+		t.Fatal("subsequence matches must not be lost")
+	}
+	if Score("drf", "Drift") < 0 || Score("frd", "Drift") >= 0 {
+		t.Fatal("fuzzy letters must stay in order")
+	}
+	projects[1].Name = "Cardly"
+	if _, err := Lookup(projects, "Cardly"); err == nil {
+		t.Fatal("duplicate display names require ID")
+	}
+}
+
+func TestOrderingAndCommands(t *testing.T) {
+	now := time.Now()
+	projects := []Project{{ID: "recent", Name: "Zed", LastUsed: now}, {ID: "fav", Name: "Alpha", Favorite: true}, {ID: "old", Name: "Beta"}}
+	Sort(projects)
+	if projects[0].ID != "fav" || projects[1].ID != "recent" {
+		t.Fatalf("wrong order: %+v", projects)
+	}
+	p := Project{AutoCommands: map[string]string{"dev": "npm run dev", "test": "npm test"}, Commands: map[string]string{"dev": "pnpm dev"}, Tools: map[string]bool{"opencode": false}}
+	if p.AllCommands()["dev"] != "pnpm dev" || p.AllCommands()["test"] != "npm test" {
+		t.Fatal("custom commands should override detection")
+	}
+	if p.ToolEnabled("opencode") || !p.ToolEnabled("vscode") {
+		t.Fatal("unexpected tool settings")
+	}
+	p.AllCommands()["test"] = "changed"
+	if p.AutoCommands["test"] != "npm test" {
+		t.Fatal("merged command map must not alias the project")
+	}
+}
+
+func TestCanonicalPath(t *testing.T) {
+	dir := t.TempDir()
+	path, err := CanonicalPath(filepath.Join(dir, "."))
+	if err != nil || !SamePath(path, dir) {
+		t.Fatalf("%q %v", path, err)
+	}
+	if _, err := CanonicalPath(filepath.Join(dir, "missing")); err == nil {
+		t.Fatal("missing directory accepted")
+	}
+}

package/internal/tools/lookup.go

@@ -0,0 +1,41 @@
+package tools
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+)
+
+// LookPath also finds VS Code's bundled macOS launcher. Installing its shell
+// command manually is optional when the app is in an Applications directory.
+func LookPath(name string) (string, error) {
+	path, err := exec.LookPath(name)
+	if err == nil {
+		return path, nil
+	}
+	if runtime.GOOS == "darwin" && name == "code" {
+		if app := applicationPath("Visual Studio Code", applicationDirectories()); app != "" {
+			return exec.LookPath(filepath.Join(app, "Contents", "Resources", "app", "bin", "code"))
+		}
+	}
+	return "", err
+}
+
+func applicationDirectories() []string {
+	dirs := []string{"/Applications"}
+	if home, err := os.UserHomeDir(); err == nil {
+		dirs = append(dirs, filepath.Join(home, "Applications"))
+	}
+	return dirs
+}
+
+func applicationPath(name string, dirs []string) string {
+	for _, dir := range dirs {
+		path := filepath.Join(dir, name+".app")
+		if info, err := os.Stat(path); err == nil && info.IsDir() {
+			return path
+		}
+	}
+	return ""
+}

package/internal/tools/platform_unix.go

@@ -0,0 +1,34 @@
+//go:build !windows
+
+package tools
+
+import (
+	"os"
+	"os/exec"
+	"syscall"
+)
+
+func executable(name string, args ...string) (*exec.Cmd, error) {
+	path, err := LookPath(name)
+	if err != nil {
+		return nil, err
+	}
+	return exec.Command(path, args...), nil
+}
+
+func Shell(path, command string) *exec.Cmd {
+	shell := os.Getenv("SHELL")
+	if shell == "" {
+		shell = "/bin/sh"
+	}
+	var cmd *exec.Cmd
+	if command == "" {
+		cmd = exec.Command(shell)
+	} else {
+		cmd = exec.Command(shell, "-c", command)
+	}
+	cmd.Dir = path
+	return cmd
+}
+
+func background(cmd *exec.Cmd) { cmd.SysProcAttr = &syscall.SysProcAttr{Setsid: true} }

package/internal/tools/platform_windows.go

@@ -0,0 +1,52 @@
+package tools
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+	"syscall"
+)
+
+func executable(name string, args ...string) (*exec.Cmd, error) {
+	path, err := exec.LookPath(name)
+	if err != nil {
+		return nil, err
+	}
+	if strings.HasSuffix(strings.ToLower(path), ".cmd") || strings.HasSuffix(strings.ToLower(path), ".bat") {
+		// CmdLine avoids Go's CRT argument escaping, which cmd.exe does not use.
+		// Reject expansion characters in generated arguments to keep paths literal.
+		all := append([]string{path}, args...)
+		for i, arg := range all {
+			if strings.ContainsAny(arg, "\"%\r\n") {
+				return nil, fmt.Errorf("batch launcher cannot safely pass this path: %s", arg)
+			}
+			all[i] = "\"" + arg + "\""
+		}
+		cmd := exec.Command("cmd.exe")
+		cmd.SysProcAttr = &syscall.SysProcAttr{CmdLine: "cmd.exe /d /v:off /s /c \"" + strings.Join(all, " ") + "\""}
+		return cmd, nil
+	}
+	return exec.Command(path, args...), nil
+}
+
+func Shell(path, command string) *exec.Cmd {
+	var cmd *exec.Cmd
+	if command != "" {
+		cmd = exec.Command("cmd.exe")
+		cmd.SysProcAttr = &syscall.SysProcAttr{CmdLine: "cmd.exe /d /s /c \"" + command + "\""}
+	} else if pwsh, err := exec.LookPath("pwsh"); err == nil {
+		cmd = exec.Command(pwsh, "-NoLogo")
+	} else {
+		cmd = exec.Command("powershell.exe", "-NoLogo")
+	}
+	cmd.Dir = path
+	return cmd
+}
+
+func background(cmd *exec.Cmd) {
+	if cmd.SysProcAttr == nil {
+		cmd.SysProcAttr = &syscall.SysProcAttr{}
+	}
+	cmd.SysProcAttr.HideWindow = true
+	cmd.SysProcAttr.CreationFlags |= 0x00000200 // CREATE_NEW_PROCESS_GROUP
+}

package/internal/tools/platform_windows_test.go

@@ -0,0 +1,29 @@
+package tools
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestBatchLauncherPassesDirectoryLiterally(t *testing.T) {
+	dir := t.TempDir()
+	launcher := filepath.Join(dir, "rian-test-launcher.cmd")
+	if err := os.WriteFile(launcher, []byte("@echo off\r\necho \"%~1\"\r\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	argument := filepath.Join(dir, "A & B!")
+	cmd, err := executable(launcher, argument)
+	if err != nil {
+		t.Fatal(err)
+	}
+	background(cmd)
+	output, err := cmd.CombinedOutput()
+	if err != nil || !strings.Contains(string(output), argument) {
+		t.Fatalf("batch argument changed: %q %v", output, err)
+	}
+	if _, err := executable(launcher, filepath.Join(dir, "%PATH%")); err == nil {
+		t.Fatal("cmd expansion characters must be rejected")
+	}
+}

package/internal/tools/tools.go

@@ -0,0 +1,152 @@
+// Package tools isolates launchers from the interface. Interactive tools return
+// an exec.Cmd that Bubble Tea can run while suspending its terminal renderer.
+package tools
+
+import (
+	"errors"
+	"fmt"
+	"net/url"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+
+	"rian/internal/git"
+	"rian/internal/project"
+)
+
+type Launcher interface {
+	OpenURL(string) error
+	OpenEditor(project.Project) error
+	Interactive(string, project.Project) (*exec.Cmd, error)
+}
+
+type System struct{}
+
+func checkDirectory(p project.Project) error {
+	info, err := os.Stat(p.Path)
+	if err != nil || !info.IsDir() {
+		return fmt.Errorf("this directory is no longer available: %s", p.Path)
+	}
+	return nil
+}
+
+func (System) OpenEditor(p project.Project) error {
+	if err := checkDirectory(p); err != nil {
+		return err
+	}
+	cmd, err := executable("code", p.Path)
+	if err != nil {
+		if errors.Is(err, exec.ErrNotFound) {
+			return fmt.Errorf("VS Code was not found in PATH; install its 'code' launcher")
+		}
+		return err
+	}
+	cmd.Dir = p.Path
+	return detach(cmd)
+}
+
+func (System) Interactive(name string, p project.Project) (*exec.Cmd, error) {
+	if err := checkDirectory(p); err != nil {
+		return nil, err
+	}
+	if name == "terminal" {
+		return Shell(p.Path, ""), nil
+	}
+	if name == "kilocode" {
+		if _, err := exec.LookPath("kilo"); err == nil {
+			name = "kilo"
+		}
+	}
+	cmd, err := executable(name)
+	if err != nil {
+		return nil, fmt.Errorf("%s was not found in PATH", name)
+	}
+	cmd.Dir = p.Path
+	return cmd, nil
+}
+
+func (s System) OpenChatGPT() error {
+	if _, err := exec.LookPath("chatgpt"); err == nil {
+		cmd, err := executable("chatgpt")
+		if err == nil {
+			return detach(cmd)
+		}
+	}
+	if runtime.GOOS == "darwin" {
+		if app := applicationPath("ChatGPT", applicationDirectories()); app != "" {
+			return detach(exec.Command("/usr/bin/open", "-a", app))
+		}
+	}
+	return s.OpenURL("https://chatgpt.com")
+}
+
+func GitHubURL(p project.Project, status git.Status) (string, error) {
+	repo := p.GitHub
+	if repo == "" {
+		repo = status.GitHub
+	}
+	if repo == "" {
+		return "", fmt.Errorf("this project has no GitHub remote; add an override in Edit Project")
+	}
+	repo, err := git.NormalizeRepo(repo)
+	if err != nil {
+		return "", err
+	}
+	return "https://github.com/" + repo, nil
+}
+
+func ValidateURL(value string) error {
+	if value == "" {
+		return nil
+	}
+	u, err := url.Parse(value)
+	if err != nil || u.Hostname() == "" || u.Scheme != "https" && u.Scheme != "http" {
+		return fmt.Errorf("use a complete http:// or https:// URL")
+	}
+	return nil
+}
+
+func (System) OpenURL(value string) error {
+	if err := ValidateURL(value); err != nil {
+		return err
+	}
+	var cmd *exec.Cmd
+	switch runtime.GOOS {
+	case "windows":
+		cmd = exec.Command("rundll32.exe", "url.dll,FileProtocolHandler", value)
+	case "darwin":
+		cmd = exec.Command("open", value)
+	default:
+		if _, err := exec.LookPath("xdg-open"); err == nil {
+			cmd = exec.Command("xdg-open", value)
+		} else {
+			cmd = exec.Command("gio", "open", value)
+		}
+	}
+	return detach(cmd)
+}
+
+func detach(cmd *exec.Cmd) error {
+	background(cmd)
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+	// Reap the child without tying a graphical application's lifetime to Rian.
+	go func() { _ = cmd.Wait() }()
+	return nil
+}
+
+func GitCommand(p project.Project, args ...string) (*exec.Cmd, error) {
+	if err := checkDirectory(p); err != nil {
+		return nil, err
+	}
+	cmd, err := executable("git", args...)
+	if err != nil {
+		return nil, fmt.Errorf("Git was not found in PATH")
+	}
+	cmd.Dir = p.Path
+	return cmd, nil
+}
+
+func CommandPreview(command string) string { return strings.TrimSpace(command) }

package/internal/tools/tools_test.go

@@ -0,0 +1,56 @@
+package tools
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"rian/internal/git"
+	"rian/internal/project"
+)
+
+func TestURLsAndRepositoryOverride(t *testing.T) {
+	for _, value := range []string{"https://chatgpt.com", "http://localhost:3000", "https://example.com/a?x=1", ""} {
+		if err := ValidateURL(value); err != nil {
+			t.Errorf("%q: %v", value, err)
+		}
+	}
+	for _, value := range []string{"javascript:alert(1)", "file:///tmp/a", "https://", "example.com"} {
+		if err := ValidateURL(value); err == nil {
+			t.Errorf("accepted %q", value)
+		}
+	}
+	value, err := GitHubURL(project.Project{GitHub: "override/repo"}, git.Status{GitHub: "detected/repo"})
+	if err != nil || value != "https://github.com/override/repo" {
+		t.Fatalf("%s %v", value, err)
+	}
+	if _, err := GitHubURL(project.Project{}, git.Status{}); err == nil {
+		t.Fatal("missing remote accepted")
+	}
+}
+
+func TestMacApplicationsInSystemAndUserDirectories(t *testing.T) {
+	root := t.TempDir()
+	system, user := filepath.Join(root, "Applications"), filepath.Join(root, "User Applications")
+	app := filepath.Join(user, "Visual Studio Code.app")
+	if err := os.MkdirAll(app, 0700); err != nil {
+		t.Fatal(err)
+	}
+	if path := applicationPath("Visual Studio Code", []string{system, user}); path != app {
+		t.Fatalf("application path: %q", path)
+	}
+	if path := applicationPath("Missing", []string{system, user}); path != "" {
+		t.Fatalf("missing app accepted: %q", path)
+	}
+}
+
+func TestShellRunsInSelectedDirectory(t *testing.T) {
+	dir := t.TempDir()
+	cmd := Shell(dir, "echo rian-command-ok")
+	background(cmd)
+	output, err := cmd.CombinedOutput()
+	if err != nil || !strings.Contains(string(output), "rian-command-ok") || cmd.Dir != dir {
+		t.Fatalf("%s %v", output, err)
+	}
+}