feat: wire context resolution into CLI and TUI commands

cmd/context_helpers.go

@@ -0,0 +1,49 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/chris-regnier/diaryctl/internal/context"
+	"github.com/chris-regnier/diaryctl/internal/entry"
+)
+
+// buildContentProviders creates ContentProviders from config names, skipping unknown.
+func buildContentProviders(names []string) []context.ContentProvider {
+	var providers []context.ContentProvider
+	for _, name := range names {
+		p := context.LookupContentProvider(name)
+		if p != nil {
+			providers = append(providers, p)
+		}
+	}
+	return providers
+}
+
+// buildContextResolvers creates ContextResolvers from config names, skipping unknown.
+func buildContextResolvers(names []string) []context.ContextResolver {
+	var resolvers []context.ContextResolver
+	for _, name := range names {
+		r := context.LookupContextResolver(name)
+		if r != nil {
+			resolvers = append(resolvers, r)
+		}
+	}
+	return resolvers
+}
+
+// resolveContexts is a convenience function that builds resolvers from config,
+// loads manual contexts, calls ResolveActiveContexts, and prints warnings.
+// Returns the resolved context refs.
+func resolveContexts() []entry.ContextRef {
+	resolvers := buildContextResolvers(appConfig.ContextResolvers)
+	manual, err := context.LoadManualContexts(appConfig.DataDir)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Warning: failed to load manual contexts: %v\n", err)
+	}
+	refs, warnings := context.ResolveActiveContexts(resolvers, manual, store)
+	for _, w := range warnings {
+		fmt.Fprintf(os.Stderr, "Warning: %s\n", w)
+	}
+	return refs
+}

cmd/context_helpers_test.go

@@ -0,0 +1,50 @@
+package cmd
+
+import (
+	"testing"
+)
+
+func TestBuildContentProviders(t *testing.T) {
+	// Known providers
+	providers := buildContentProviders([]string{"datetime", "git"})
+	if len(providers) != 2 {
+		t.Fatalf("expected 2 providers, got %d", len(providers))
+	}
+	if providers[0].Name() != "datetime" {
+		t.Errorf("expected datetime, got %s", providers[0].Name())
+	}
+	if providers[1].Name() != "git" {
+		t.Errorf("expected git, got %s", providers[1].Name())
+	}
+}
+
+func TestBuildContentProvidersSkipsUnknown(t *testing.T) {
+	providers := buildContentProviders([]string{"datetime", "nonexistent"})
+	if len(providers) != 1 {
+		t.Fatalf("expected 1 provider, got %d", len(providers))
+	}
+}
+
+func TestBuildContentProvidersEmpty(t *testing.T) {
+	providers := buildContentProviders(nil)
+	if len(providers) != 0 {
+		t.Fatalf("expected 0 providers, got %d", len(providers))
+	}
+}
+
+func TestBuildContextResolvers(t *testing.T) {
+	resolvers := buildContextResolvers([]string{"git"})
+	if len(resolvers) != 1 {
+		t.Fatalf("expected 1 resolver, got %d", len(resolvers))
+	}
+	if resolvers[0].Name() != "git" {
+		t.Errorf("expected git, got %s", resolvers[0].Name())
+	}
+}
+
+func TestBuildContextResolversSkipsUnknown(t *testing.T) {
+	resolvers := buildContextResolvers([]string{"nonexistent"})
+	if len(resolvers) != 0 {
+		t.Fatalf("expected 0 resolvers, got %d", len(resolvers))
+	}
+}

cmd/create.go

@@ -7,6 +7,7 @@
 	"strings"
 	"time"
 
+	ctxpkg "github.com/chris-regnier/diaryctl/internal/context"
 	"github.com/chris-regnier/diaryctl/internal/editor"
 	"github.com/chris-regnier/diaryctl/internal/entry"
 	tmpl "github.com/chris-regnier/diaryctl/internal/template"
@@ -87,11 +88,15 @@
 				}
 			}
 
+			// Compose content from providers and template
+			providers := buildContentProviders(appConfig.ContextProviders)
+			editorContent := ctxpkg.ComposeContent(providers, templateContent)
+
 			// Open editor
 			editorCmd := editor.ResolveEditor(appConfig.Editor)
 			var err error
 			var changed bool
-			content, changed, err = editor.Edit(editorCmd, templateContent)
+			content, changed, err = editor.Edit(editorCmd, editorContent)
 			if err != nil {
 				fmt.Fprintln(os.Stderr, "Editor error:", err)
 				os.Exit(3)
@@ -115,13 +120,17 @@
 			os.Exit(2)
 		}
 
+		// Resolve active contexts
+		contextRefs := resolveContexts()
+
 		now := time.Now().UTC()
 		e := entry.Entry{
 			ID:        id,
 			Content:   strings.TrimSpace(content),
 			CreatedAt: now,
 			UpdatedAt: now,
 			Templates: templateRefs,
+			Contexts:  contextRefs,
 		}
 
 		if err := store.Create(e); err != nil {

cmd/create_test.go

@@ -7,6 +7,7 @@
 	"testing"
 	"time"
 
+	"github.com/chris-regnier/diaryctl/internal/context"
 	"github.com/chris-regnier/diaryctl/internal/entry"
 	"github.com/chris-regnier/diaryctl/internal/storage"
 	tmpl "github.com/chris-regnier/diaryctl/internal/template"
@@ -191,3 +192,50 @@
 		t.Errorf("expected ErrNotFound in error, got: %v", err)
 	}
 }
+
+func TestCreateInlineWithContextResolution(t *testing.T) {
+	setupTestEnv(t)
+	appConfig.DataDir = t.TempDir()
+	appConfig.ContextResolvers = []string{}
+
+	ctx := storage.Context{
+		ID:        "ctx001",
+		Name:      "test-context",
+		Source:    "manual",
+		CreatedAt: time.Now().UTC(),
+		UpdatedAt: time.Now().UTC(),
+	}
+	if err := store.CreateContext(ctx); err != nil {
+		t.Fatalf("CreateContext: %v", err)
+	}
+
+	if err := context.SetManualContext(appConfig.DataDir, "test-context"); err != nil {
+		t.Fatalf("SetManualContext: %v", err)
+	}
+
+	id, _ := entry.NewID()
+	now := time.Now().UTC()
+	refs := resolveContexts()
+
+	e := entry.Entry{
+		ID:        id,
+		Content:   "Entry with context",
+		CreatedAt: now,
+		UpdatedAt: now,
+		Contexts:  refs,
+	}
+	if err := store.Create(e); err != nil {
+		t.Fatalf("Create: %v", err)
+	}
+
+	got, err := store.Get(id)
+	if err != nil {
+		t.Fatalf("Get: %v", err)
+	}
+	if len(got.Contexts) != 1 {
+		t.Fatalf("expected 1 context ref, got %d", len(got.Contexts))
+	}
+	if got.Contexts[0].ContextName != "test-context" {
+		t.Errorf("context name = %q, want %q", got.Contexts[0].ContextName, "test-context")
+	}
+}

cmd/jot.go

@@ -76,6 +76,12 @@
 		return fmt.Errorf("updating entry: %w", err)
 	}
 
+	// Resolve and attach contexts
+	contextRefs := resolveContexts()
+	for _, ref := range contextRefs {
+		_ = store.AttachContext(e.ID, ref.ContextID)
+	}
+
 	if jsonOutput {
 		return ui.FormatJSON(w, updated)
 	}

cmd/jot_test.go

@@ -9,6 +9,7 @@
 	"time"
 
 	"github.com/chris-regnier/diaryctl/internal/config"
+	"github.com/chris-regnier/diaryctl/internal/context"
 	"github.com/chris-regnier/diaryctl/internal/daily"
 	"github.com/chris-regnier/diaryctl/internal/entry"
 	"github.com/chris-regnier/diaryctl/internal/storage"
@@ -183,3 +184,90 @@
 		t.Error("expected jot content in JSON")
 	}
 }
+
+func TestJotAttachesContextsToNewEntry(t *testing.T) {
+	s := setupTestStore(t)
+	store = s
+	appConfig = &config.Config{}
+	appConfig.DataDir = t.TempDir()
+	appConfig.ContextResolvers = []string{}
+
+	ctx := storage.Context{
+		ID:        "ctx001",
+		Name:      "sprint-1",
+		Source:    "manual",
+		CreatedAt: time.Now().UTC(),
+		UpdatedAt: time.Now().UTC(),
+	}
+	if err := s.CreateContext(ctx); err != nil {
+		t.Fatalf("CreateContext: %v", err)
+	}
+	if err := context.SetManualContext(appConfig.DataDir, "sprint-1"); err != nil {
+		t.Fatalf("SetManualContext: %v", err)
+	}
+
+	err := jotRun(io.Discard, "hello", "")
+	if err != nil {
+		t.Fatalf("jotRun: %v", err)
+	}
+
+	e, _, err := daily.GetOrCreateToday(s, "")
+	if err != nil {
+		t.Fatalf("GetOrCreateToday: %v", err)
+	}
+
+	got, err := s.Get(e.ID)
+	if err != nil {
+		t.Fatalf("Get: %v", err)
+	}
+	if len(got.Contexts) != 1 {
+		t.Fatalf("expected 1 context, got %d", len(got.Contexts))
+	}
+	if got.Contexts[0].ContextName != "sprint-1" {
+		t.Errorf("context = %q, want sprint-1", got.Contexts[0].ContextName)
+	}
+}
+
+func TestJotAttachesContextsToExistingEntry(t *testing.T) {
+	s := setupTestStore(t)
+	store = s
+	appConfig = &config.Config{}
+	appConfig.DataDir = t.TempDir()
+	appConfig.ContextResolvers = []string{}
+
+	_, _, err := daily.GetOrCreateToday(s, "")
+	if err != nil {
+		t.Fatalf("GetOrCreateToday: %v", err)
+	}
+
+	ctx := storage.Context{
+		ID:        "ctx002",
+		Name:      "bugfix",
+		Source:    "manual",
+		CreatedAt: time.Now().UTC(),
+		UpdatedAt: time.Now().UTC(),
+	}
+	if err := s.CreateContext(ctx); err != nil {
+		t.Fatalf("CreateContext: %v", err)
+	}
+	if err := context.SetManualContext(appConfig.DataDir, "bugfix"); err != nil {
+		t.Fatalf("SetManualContext: %v", err)
+	}
+
+	err = jotRun(io.Discard, "fixed the bug", "")
+	if err != nil {
+		t.Fatalf("jotRun: %v", err)
+	}
+
+	e, _, _ := daily.GetOrCreateToday(s, "")
+	got, err := s.Get(e.ID)
+	if err != nil {
+		t.Fatalf("Get: %v", err)
+	}
+	if len(got.Contexts) != 1 {
+		t.Fatalf("expected 1 context, got %d", len(got.Contexts))
+	}
+	if got.Contexts[0].ContextName != "bugfix" {
+		t.Errorf("context = %q, want bugfix", got.Contexts[0].ContextName)
+	}
+}

cmd/root.go

@@ -63,10 +63,13 @@ var rootCmd = &cobra.Command{
 			return todayRun(os.Stdout, false, false)
 		}
 		return ui.RunTUI(store, ui.TUIConfig{
-			Editor:          editor.ResolveEditor(appConfig.Editor),
-			DefaultTemplate: appConfig.DefaultTemplate,
-			MaxWidth:        appConfig.MaxWidth,
-			Theme:           ui.ResolveTheme(appConfig.Theme),
+			Editor:           editor.ResolveEditor(appConfig.Editor),
+			DefaultTemplate:  appConfig.DefaultTemplate,
+			MaxWidth:         appConfig.MaxWidth,
+			Theme:            ui.ResolveTheme(appConfig.Theme),
+			ContextProviders: appConfig.ContextProviders,
+			ContextResolvers: appConfig.ContextResolvers,
+			DataDir:          appConfig.DataDir,
 		})
 	},
 }

cmd/today.go

@@ -43,6 +43,12 @@
 		return fmt.Errorf("getting today's entry: %w", err)
 	}
 
+	// Resolve and attach contexts
+	contextRefs := resolveContexts()
+	for _, ref := range contextRefs {
+		_ = store.AttachContext(e.ID, ref.ContextID)
+	}
+
 	if jsonOutput {
 		return ui.FormatJSON(w, e)
 	}
@@ -69,6 +75,12 @@
 		return fmt.Errorf("getting today's entry: %w", err)
 	}
 
+	// Resolve and attach contexts
+	contextRefs := resolveContexts()
+	for _, ref := range contextRefs {
+		_ = store.AttachContext(e.ID, ref.ContextID)
+	}
+
 	editorCmd := editor.ResolveEditor(appConfig.Editor)
 	content, changed, err := editor.Edit(editorCmd, e.Content)
 	if err != nil {