refactor: use config constants throughout codebase

- Update claude package to use config constants for hook scripts
- Move DefaultPermissions from claude/perm.go to config package
- Rename internal/templates to internal/tpl
- Update all imports for templates→tpl rename
- Add tests for bootstrap, decision, journal, learnings, recall, serve
- Use config constants in marker.go and token.go

Signed-off-by: Jose Alekhinne <alekhinejose@gmail.com>

Author: josealekhine

internal/bootstrap/bootstrap.go

@@ -62,7 +62,7 @@ func RootCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "ctx",
 		Short: "Context - persistent context for AI coding assistants",
-		Long: `Context (ctx) maintains persistent context files that help
+		Long: `ctx (Context) maintains persistent context files that help
   AI coding assistants understand your project's architecture, conventions,
   decisions, and current tasks.
 

internal/bootstrap/bootstrap_test.go

@@ -0,0 +1,99 @@
+//   /    Context:                     https://ctx.ist
+// ,'`./    do you remember?
+// `.,'\
+//   \    Copyright 2026-present Context contributors.
+//                 SPDX-License-Identifier: Apache-2.0
+
+package bootstrap
+
+import (
+	"testing"
+)
+
+func TestRootCmd(t *testing.T) {
+	cmd := RootCmd()
+
+	if cmd == nil {
+		t.Fatal("RootCmd() returned nil")
+	}
+
+	if cmd.Use != "ctx" {
+		t.Errorf("RootCmd().Use = %q, want %q", cmd.Use, "ctx")
+	}
+
+	if cmd.Short == "" {
+		t.Error("RootCmd().Short is empty")
+	}
+
+	if cmd.Long == "" {
+		t.Error("RootCmd().Long is empty")
+	}
+
+	// Check global flags exist
+	contextDirFlag := cmd.PersistentFlags().Lookup("context-dir")
+	if contextDirFlag == nil {
+		t.Error("--context-dir flag not found")
+	}
+
+	noColorFlag := cmd.PersistentFlags().Lookup("no-color")
+	if noColorFlag == nil {
+		t.Error("--no-color flag not found")
+	}
+}
+
+func TestInitialize(t *testing.T) {
+	root := RootCmd()
+	cmd := Initialize(root)
+
+	if cmd == nil {
+		t.Fatal("Initialize() returned nil")
+	}
+
+	// Verify all expected subcommands are registered
+	expectedCommands := []string{
+		"init",
+		"status",
+		"load",
+		"add",
+		"complete",
+		"agent",
+		"drift",
+		"sync",
+		"compact",
+		"decisions",
+		"watch",
+		"hook",
+		"learnings",
+		"session",
+		"tasks",
+		"loop",
+		"recall",
+		"journal",
+		"serve",
+	}
+
+	commands := make(map[string]bool)
+	for _, c := range cmd.Commands() {
+		commands[c.Use] = true
+		// Handle commands with args in Use (e.g., "serve [directory]")
+		for _, exp := range expectedCommands {
+			if c.Name() == exp {
+				commands[exp] = true
+			}
+		}
+	}
+
+	for _, exp := range expectedCommands {
+		if !commands[exp] {
+			t.Errorf("missing subcommand: %s", exp)
+		}
+	}
+}
+
+func TestRootCmdVersion(t *testing.T) {
+	cmd := RootCmd()
+
+	if cmd.Version == "" {
+		t.Error("RootCmd().Version is empty")
+	}
+}

internal/claude/claude_test.go

@@ -45,6 +45,28 @@ func TestBlockNonPathCtxScript(t *testing.T) {
 	}
 }
 
+func TestPromptCoachScript(t *testing.T) {
+	content, err := PromptCoachScript()
+	if err != nil {
+		t.Fatalf("PromptCoachScript() unexpected error: %v", err)
+	}
+
+	if len(content) == 0 {
+		t.Error("PromptCoachScript() returned empty content")
+	}
+
+	// Check for expected script content
+	script := string(content)
+	if !strings.Contains(script, "#!/") {
+		t.Error("PromptCoachScript() script missing shebang")
+	}
+
+	// Check that it contains pattern detection logic
+	if !strings.Contains(script, "idiomatic") {
+		t.Error("PromptCoachScript() should contain anti-pattern detection")
+	}
+}
+
 func TestCommands(t *testing.T) {
 	commands, err := Commands()
 	if err != nil {
@@ -156,29 +178,3 @@ func TestSettingsStructure(t *testing.T) {
 	}
 }
 
-func TestDefaultPermissions(t *testing.T) {
-	perms := DefaultPermissions()
-
-	if len(perms) == 0 {
-		t.Error("DefaultPermissions should return permissions")
-	}
-
-	// Check that essential ctx commands are included
-	expected := []string{
-		"Bash(ctx status:*)",
-		"Bash(ctx agent:*)",
-		"Bash(ctx add:*)",
-		"Bash(ctx session:*)",
-	}
-
-	permSet := make(map[string]bool)
-	for _, p := range perms {
-		permSet[p] = true
-	}
-
-	for _, e := range expected {
-		if !permSet[e] {
-			t.Errorf("Missing expected permission: %s", e)
-		}
-	}
-}

internal/claude/cmd.go

@@ -9,7 +9,7 @@ package claude
 import (
 	"fmt"
 
-	"github.com/ActiveMemory/ctx/internal/templates"
+	"github.com/ActiveMemory/ctx/internal/tpl"
 )
 
 // Commands returns the list of embedded command file names.
@@ -22,7 +22,7 @@ import (
 //   - []string: Filenames of available command definitions
 //   - error: Non-nil if the commands directory cannot be read
 func Commands() ([]string, error) {
-	names, err := templates.ListClaudeCommands()
+	names, err := tpl.ListClaudeCommands()
 	if err != nil {
 		return nil, fmt.Errorf("failed to list commands: %w", err)
 	}
@@ -38,7 +38,7 @@ func Commands() ([]string, error) {
 //   - []byte: Raw bytes of the command definition file
 //   - error: Non-nil if the command file does not exist or cannot be read
 func CommandByName(name string) ([]byte, error) {
-	content, err := templates.GetClaudeCommand(name)
+	content, err := tpl.ClaudeCommandByName(name)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read command %s: %w", name, err)
 	}

internal/claude/hook.go

@@ -6,7 +6,11 @@
 
 package claude
 
-import "fmt"
+import (
+	"fmt"
+
+	"github.com/ActiveMemory/ctx/internal/config"
+)
 
 // DefaultHooks returns the default ctx hooks configuration for
 // Claude Code.
@@ -24,9 +28,11 @@ import "fmt"
 //   - HookConfig: Configured hooks for PreToolUse, UserPromptSubmit, and
 //     SessionEnd events
 func DefaultHooks(projectDir string) HookConfig {
-	hooksDir := ".claude/hooks"
+	hooksDir := config.DirClaudeHooks
 	if projectDir != "" {
-		hooksDir = fmt.Sprintf("%s/.claude/hooks", projectDir)
+		hooksDir = fmt.Sprintf(
+			"%s/%s", projectDir, config.DirClaudeHooks,
+		)
 	}
 
 	return HookConfig{
@@ -36,8 +42,10 @@ func DefaultHooks(projectDir string) HookConfig {
 				Matcher: "Bash",
 				Hooks: []Hook{
 					{
-						Type:    "command",
-						Command: fmt.Sprintf("%s/block-non-path-ctx.sh", hooksDir),
+						Type: "command",
+						Command: fmt.Sprintf(
+							"%s/%s", hooksDir, config.FileBlockNonPathScript,
+						),
 					},
 				},
 			},
@@ -58,7 +66,7 @@ func DefaultHooks(projectDir string) HookConfig {
 				Hooks: []Hook{
 					{
 						Type:    "command",
-						Command: fmt.Sprintf("%s/prompt-coach.sh", hooksDir),
+						Command: fmt.Sprintf("%s/%s", hooksDir, config.FilePromptCoach),
 					},
 				},
 			},
@@ -68,7 +76,7 @@ func DefaultHooks(projectDir string) HookConfig {
 				Hooks: []Hook{
 					{
 						Type:    "command",
-						Command: fmt.Sprintf("%s/auto-save-session.sh", hooksDir),
+						Command: fmt.Sprintf("%s/%s", hooksDir, config.FileAutoSave),
 					},
 				},
 			},

internal/claude/perm.go

@@ -9,7 +9,8 @@ package claude
 import (
 	"fmt"
 
-	"github.com/ActiveMemory/ctx/internal/templates"
+	"github.com/ActiveMemory/ctx/internal/config"
+	"github.com/ActiveMemory/ctx/internal/tpl"
 )
 
 // AutoSaveScript returns the auto-save session script content.
@@ -21,9 +22,9 @@ import (
 //   - []byte: Raw bytes of the auto-save-session.sh script
 //   - error: Non-nil if the embedded file cannot be read
 func AutoSaveScript() ([]byte, error) {
-	content, err := templates.ClaudeHookByFileName("auto-save-session.sh")
+	content, err := tpl.ClaudeHookByFileName(config.FileAutoSave)
 	if err != nil {
-		return nil, fmt.Errorf("failed to read auto-save-session.sh: %w", err)
+		return nil, fmt.Errorf("failed to read %s: %w", config.FileAutoSave, err)
 	}
 	return content, nil
 }
@@ -39,16 +40,18 @@ func AutoSaveScript() ([]byte, error) {
 //   - []byte: Raw bytes of the block-non-path-ctx.sh script
 //   - error: Non-nil if the embedded file cannot be read
 func BlockNonPathCtxScript() ([]byte, error) {
-	content, err := templates.ClaudeHookByFileName("block-non-path-ctx.sh")
+	content, err := tpl.ClaudeHookByFileName(config.FileBlockNonPathScript)
 	if err != nil {
-		return nil, fmt.Errorf("failed to read block-non-path-ctx.sh: %w", err)
+		return nil, fmt.Errorf(
+			"failed to read %s: %w", config.FileBlockNonPathScript, err,
+		)
 	}
 	return content, nil
 }
 
 // PromptCoachScript returns the prompt coaching hook script.
 //
-// The script detects prompt anti-patterns (e.g., "idiomatic Go") and suggests
+// The script detects prompt antipatterns (e.g., "idiomatic Go") and suggests
 // better alternatives (e.g., "follow project conventions"). It limits
 // suggestions to 3 per pattern per session to avoid annoying the user.
 // It is installed to .claude/hooks/ during ctx init --claude.
@@ -57,9 +60,11 @@ func BlockNonPathCtxScript() ([]byte, error) {
 //   - []byte: Raw bytes of the prompt-coach.sh script
 //   - error: Non-nil if the embedded file cannot be read
 func PromptCoachScript() ([]byte, error) {
-	content, err := templates.ClaudeHookByFileName("prompt-coach.sh")
+	content, err := tpl.ClaudeHookByFileName(config.FilePromptCoach)
 	if err != nil {
-		return nil, fmt.Errorf("failed to read prompt-coach.sh: %w", err)
+		return nil, fmt.Errorf(
+			"failed to read %s: %w", config.FilePromptCoach, err,
+		)
 	}
 	return content, nil
 }

internal/claude/script.go

@@ -15,6 +15,20 @@ import (
 	"github.com/ActiveMemory/ctx/internal/config"
 )
 
+// extractContent retrieves content from various sources for adding entries.
+//
+// Content is extracted in priority order:
+//  1. From the file specified by --file flag
+//  2. From command line arguments (after the entry type)
+//  3. From stdin (if piped)
+//
+// Parameters:
+//   - args: Command arguments where args[1:] may contain inline content
+//   - flags: Configuration flags including fromFile path
+//
+// Returns:
+//   - string: Extracted and trimmed content
+//   - error: Non-nil if no content source is available or reading fails
 func extractContent(args []string, flags addConfig) (string, error) {
 	if flags.fromFile != "" {
 		// Read from the file

internal/cli/add/content.go

@@ -11,7 +11,7 @@ import (
 	"time"
 )
 
-// FormatTask formats a task entry as a markdown checkbox item.
+// FormatTask formats a task entry as a Markdown checkbox item.
 //
 // The output includes a timestamp tag for session correlation and an optional
 // priority tag. Format: "- [ ] content #priority:level #added:YYYY-MM-DD-HHMMSS"
@@ -32,7 +32,7 @@ func FormatTask(content string, priority string) string {
 	return fmt.Sprintf("- [ ] %s%s #added:%s\n", content, priorityTag, timestamp)
 }
 
-// FormatLearning formats a learning entry as a structured markdown section.
+// FormatLearning formats a learning entry as a structured Markdown section.
 //
 // The output includes a timestamped heading and complete sections for context,
 // lesson, and application.
@@ -57,7 +57,7 @@ func FormatLearning(title, context, lesson, application string) string {
 `, timestamp, title, context, lesson, application)
 }
 
-// FormatConvention formats a convention entry as a simple markdown list item.
+// FormatConvention formats a convention entry as a simple Markdown list item.
 //
 // Format: "- content"
 //