test: add tests for 8 previously untested packages

Added tests for privacy, dedup, intent, conflict, config, utils, hooks,
and mental packages. All passing.

Author: Patel230

config/config_test.go

@@ -0,0 +1,87 @@
+package config
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestDefault(t *testing.T) {
+	cfg := Default()
+
+	if cfg.Server.Port != 3456 {
+		t.Errorf("expected port 3456, got %d", cfg.Server.Port)
+	}
+	if cfg.Server.Host != "127.0.0.1" {
+		t.Errorf("expected host 127.0.0.1, got %s", cfg.Server.Host)
+	}
+	if cfg.Memory.HotTokenBudget != 800 {
+		t.Errorf("expected hot token budget 800, got %d", cfg.Memory.HotTokenBudget)
+	}
+	if cfg.Decay.HalfLifeDays != 30 {
+		t.Errorf("expected half life 30, got %d", cfg.Decay.HalfLifeDays)
+	}
+	if !cfg.Decay.Enabled {
+		t.Error("expected decay to be enabled by default")
+	}
+	if !cfg.Git.Watch {
+		t.Error("expected git watch to be enabled by default")
+	}
+}
+
+func TestLoad_NoConfigFile(t *testing.T) {
+	cfg, err := Load("/nonexistent/path")
+	if err != nil {
+		t.Fatalf("loading from nonexistent path should not error: %v", err)
+	}
+	if cfg.Server.Port != 3456 {
+		t.Errorf("expected defaults when no config file, got port %d", cfg.Server.Port)
+	}
+}
+
+func TestLoad_ProjectConfig(t *testing.T) {
+	dir := t.TempDir()
+	yaadDir := filepath.Join(dir, ".yaad")
+	os.MkdirAll(yaadDir, 0o755)
+
+	configContent := `[server]
+port = 9999
+host = "0.0.0.0"
+
+[memory]
+hot_token_budget = 1600
+
+[decay]
+half_life_days = 60
+`
+	os.WriteFile(filepath.Join(yaadDir, "config.toml"), []byte(configContent), 0o644)
+
+	cfg, err := Load(dir)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if cfg.Server.Port != 9999 {
+		t.Errorf("expected port 9999 from project config, got %d", cfg.Server.Port)
+	}
+	if cfg.Server.Host != "0.0.0.0" {
+		t.Errorf("expected host 0.0.0.0, got %s", cfg.Server.Host)
+	}
+	if cfg.Memory.HotTokenBudget != 1600 {
+		t.Errorf("expected hot budget 1600, got %d", cfg.Memory.HotTokenBudget)
+	}
+	if cfg.Decay.HalfLifeDays != 60 {
+		t.Errorf("expected half life 60, got %d", cfg.Decay.HalfLifeDays)
+	}
+}
+
+func TestLoad_InvalidTOML(t *testing.T) {
+	dir := t.TempDir()
+	yaadDir := filepath.Join(dir, ".yaad")
+	os.MkdirAll(yaadDir, 0o755)
+	os.WriteFile(filepath.Join(yaadDir, "config.toml"), []byte("invalid [[[ toml"), 0o644)
+
+	_, err := Load(dir)
+	if err == nil {
+		t.Error("expected error for invalid TOML")
+	}
+}

conflict/resolver_test.go

@@ -0,0 +1,96 @@
+package conflict
+
+import (
+	"testing"
+
+	"github.com/GrayCodeAI/yaad/storage"
+)
+
+func TestIsContradiction_ExplicitSignal(t *testing.T) {
+	newNode := &storage.Node{
+		Content:    "Use jose library instead of jsonwebtoken for JWT validation",
+		Type:       "convention",
+		Confidence: 1.0,
+	}
+	oldNode := &storage.Node{
+		Content:    "Use jsonwebtoken library for JWT validation in the auth service",
+		Type:       "convention",
+		Confidence: 1.0,
+	}
+	if !isContradiction(newNode, oldNode) {
+		t.Error("expected contradiction: 'instead of' signal with shared terms")
+	}
+}
+
+func TestIsContradiction_NoOverlap(t *testing.T) {
+	newNode := &storage.Node{
+		Content:    "Deploy using Docker containers",
+		Type:       "decision",
+		Confidence: 1.0,
+	}
+	oldNode := &storage.Node{
+		Content:    "Use PostgreSQL for the main database",
+		Type:       "decision",
+		Confidence: 1.0,
+	}
+	if isContradiction(newNode, oldNode) {
+		t.Error("no shared terms should not be a contradiction")
+	}
+}
+
+func TestIsContradiction_SameDecisionUpdated(t *testing.T) {
+	newNode := &storage.Node{
+		Content:    "Authentication uses RS256 algorithm with rotating keys for token signing",
+		Type:       "decision",
+		Confidence: 1.0,
+	}
+	oldNode := &storage.Node{
+		Content:    "Authentication uses HS256 algorithm with static secret for token signing",
+		Type:       "decision",
+		Confidence: 1.0,
+	}
+	if !isContradiction(newNode, oldNode) {
+		t.Error("same-topic decisions with different content should be contradictions")
+	}
+}
+
+func TestIsContradiction_LowOverlap(t *testing.T) {
+	newNode := &storage.Node{
+		Content:    "The server runs on port 8080",
+		Type:       "spec",
+		Confidence: 1.0,
+	}
+	oldNode := &storage.Node{
+		Content:    "The database schema has 12 tables",
+		Type:       "spec",
+		Confidence: 1.0,
+	}
+	if isContradiction(newNode, oldNode) {
+		t.Error("low overlap specs should not be contradictions")
+	}
+}
+
+func TestExtractKeyTerms(t *testing.T) {
+	terms := extractKeyTerms("Use the jose library for JWT validation")
+	if !terms["jose"] {
+		t.Error("expected 'jose' in key terms")
+	}
+	if !terms["library"] {
+		t.Error("expected 'library' in key terms")
+	}
+	if terms["the"] {
+		t.Error("stop word 'the' should be excluded")
+	}
+	if terms["for"] {
+		t.Error("stop word 'for' should be excluded")
+	}
+}
+
+func TestIsStopWord(t *testing.T) {
+	if !isStopWord("the") {
+		t.Error("'the' should be a stop word")
+	}
+	if isStopWord("database") {
+		t.Error("'database' should not be a stop word")
+	}
+}

dedup/window_test.go

@@ -0,0 +1,69 @@
+package dedup
+
+import (
+	"testing"
+	"time"
+)
+
+func TestWindow_BasicDedup(t *testing.T) {
+	w := New(5 * time.Minute)
+
+	if w.IsDuplicate("hello world") {
+		t.Error("first submission should not be duplicate")
+	}
+	if !w.IsDuplicate("hello world") {
+		t.Error("second identical submission should be duplicate")
+	}
+}
+
+func TestWindow_DifferentContent(t *testing.T) {
+	w := New(5 * time.Minute)
+
+	w.IsDuplicate("content A")
+	if w.IsDuplicate("content B") {
+		t.Error("different content should not be duplicate")
+	}
+}
+
+func TestWindow_WhitespaceNormalization(t *testing.T) {
+	w := New(5 * time.Minute)
+
+	w.IsDuplicate("hello   world")
+	if !w.IsDuplicate("hello\t\nworld") {
+		t.Error("whitespace-only differences should be considered duplicates")
+	}
+}
+
+func TestWindow_Expiry(t *testing.T) {
+	w := New(1 * time.Millisecond)
+
+	w.IsDuplicate("expires fast")
+	time.Sleep(5 * time.Millisecond)
+
+	if w.IsDuplicate("expires fast") {
+		t.Error("content should not be duplicate after window expires")
+	}
+}
+
+func TestWindow_DefaultDuration(t *testing.T) {
+	w := New(0)
+	if w.duration != 5*time.Minute {
+		t.Errorf("expected default 5m, got %v", w.duration)
+	}
+}
+
+func TestWindow_ConcurrentAccess(t *testing.T) {
+	w := New(5 * time.Minute)
+	done := make(chan bool, 10)
+
+	for i := 0; i < 10; i++ {
+		go func(n int) {
+			w.IsDuplicate("concurrent content")
+			done <- true
+		}(i)
+	}
+
+	for i := 0; i < 10; i++ {
+		<-done
+	}
+}

hooks/relevance_test.go

@@ -0,0 +1,82 @@
+package hooks
+
+import "testing"
+
+func TestScoreRelevance_Errors(t *testing.T) {
+	score := ScoreRelevance("Bash", "npm install", "", "exit code 1")
+	if score < 0.9 {
+		t.Errorf("errors should score 0.9, got %f", score)
+	}
+}
+
+func TestScoreRelevance_FileModifications(t *testing.T) {
+	score := ScoreRelevance("Write", "src/components/auth/main.go", "file written successfully to disk", "")
+	if score < 0.7 {
+		t.Errorf("Write tool should score >= 0.7, got %f", score)
+	}
+}
+
+func TestScoreRelevance_ReadLowSignal(t *testing.T) {
+	score := ScoreRelevance("Read", "src/main.go", "package main...", "")
+	if score > 0.5 {
+		t.Errorf("Read tool should be low signal, got %f", score)
+	}
+}
+
+func TestScoreRelevance_BashInstall(t *testing.T) {
+	score := ScoreRelevance("Bash", "npm install express morgan helmet", "added 50 packages in 3.2s", "")
+	if score < 0.7 {
+		t.Errorf("install commands should score >= 0.7, got %f", score)
+	}
+}
+
+func TestScoreRelevance_BashNavigation(t *testing.T) {
+	score := ScoreRelevance("Bash", "ls src/", "main.go utils.go", "")
+	if score > 0.3 {
+		t.Errorf("navigation commands should be low signal, got %f", score)
+	}
+}
+
+func TestScoreRelevance_DecisionSignal(t *testing.T) {
+	score := ScoreRelevance("Bash", "decided to use jose", "switched to jose library", "")
+	if score < 0.5 {
+		t.Errorf("decision signals should boost score, got %f", score)
+	}
+}
+
+func TestShouldCapture_HighSignal(t *testing.T) {
+	if !ShouldCapture("Write", "writing config", "done", "") {
+		t.Error("Write tool should pass capture threshold")
+	}
+}
+
+func TestShouldCapture_LowSignal(t *testing.T) {
+	if ShouldCapture("Read", "x", "y", "") {
+		t.Error("short Read output should not pass capture threshold")
+	}
+}
+
+func TestScoreRelevance_CappedAt1(t *testing.T) {
+	score := ScoreRelevance("Write", "decided to always enforce convention required", "written pattern", "")
+	if score > 1.0 {
+		t.Errorf("score should never exceed 1.0, got %f", score)
+	}
+}
+
+func TestContainsDecisionSignal(t *testing.T) {
+	if !containsDecisionSignal("we decided to use postgres") {
+		t.Error("should detect 'decided'")
+	}
+	if containsDecisionSignal("the weather is nice") {
+		t.Error("should not detect false positives")
+	}
+}
+
+func TestContainsConventionSignal(t *testing.T) {
+	if !containsConventionSignal("always use camelCase") {
+		t.Error("should detect 'always'")
+	}
+	if !containsConventionSignal("this is required for deployment") {
+		t.Error("should detect 'required'")
+	}
+}