Merge pull request #24 from yepzdk/feat/issue-15-capability-discovery

feat: surface capabilities to users

Author: yepzdk

internal/cli/info.go

@@ -0,0 +1,132 @@
+package cli
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+
+	"github.com/itk-dev/itkdev-claude-code/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var infoCmd = &cobra.Command{
+	Use:   "info",
+	Short: "Show capabilities, hooks, commands, and MCP tools",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		out := cmd.OutOrStdout()
+		info := buildInfo()
+
+		if jsonOutput {
+			return json.NewEncoder(out).Encode(info)
+		}
+
+		fmt.Fprintf(out, "%s v%s\n\n", info.Name, info.Version)
+
+		fmt.Fprintln(out, "Features:")
+		for _, f := range info.Features {
+			fmt.Fprintf(out, "  %-18s %s\n", f.Name, f.Description)
+		}
+
+		fmt.Fprintln(out)
+		fmt.Fprintln(out, "Commands:")
+		for _, c := range info.Commands {
+			fmt.Fprintf(out, "  %-18s %s\n", c.Name, c.Description)
+		}
+
+		fmt.Fprintln(out)
+		fmt.Fprintln(out, "Hooks:")
+		for _, h := range info.Hooks {
+			fmt.Fprintf(out, "  %-18s %s\n", h.Name, h.Description)
+		}
+
+		fmt.Fprintln(out)
+		fmt.Fprintln(out, "MCP Tools:")
+		for _, m := range info.MCPTools {
+			fmt.Fprintf(out, "  %-18s %s\n", m.Name, m.Description)
+		}
+
+		fmt.Fprintln(out)
+		fmt.Fprintln(out, "Skills:")
+		for _, s := range info.Skills {
+			fmt.Fprintf(out, "  %-18s %s\n", s.Name, s.Description)
+		}
+
+		fmt.Fprintln(out)
+		fmt.Fprintf(out, "Console: http://localhost:%s\n", strconv.Itoa(config.DefaultPort))
+		fmt.Fprintf(out, "Docs:    docs/usage.md\n")
+
+		return nil
+	},
+}
+
+// InfoData holds all capability information for JSON output.
+type InfoData struct {
+	Name     string      `json:"name"`
+	Version  string      `json:"version"`
+	Features []InfoEntry `json:"features"`
+	Commands []InfoEntry `json:"commands"`
+	Hooks    []InfoEntry `json:"hooks"`
+	MCPTools []InfoEntry `json:"mcp_tools"`
+	Skills   []InfoEntry `json:"skills"`
+}
+
+// InfoEntry is a name-description pair used across all info sections.
+type InfoEntry struct {
+	Name        string `json:"name"`
+	Description string `json:"description"`
+}
+
+func buildInfo() InfoData {
+	return InfoData{
+		Name:    config.DisplayName,
+		Version: config.Version(),
+		Features: []InfoEntry{
+			{"Quality Hooks", "Lint, format, and TDD enforcement on every edit"},
+			{"Context Mgmt", "Context monitor with Endless Mode at 90%"},
+			{"Memory", "Persistent observations with semantic search"},
+			{"Workflows", "/spec (plan → implement → verify)"},
+			{"Web Console", "Observations, sessions, plans, and search"},
+			{"Worktree", "Git worktree isolation for safe parallel work"},
+		},
+		Commands: []InfoEntry{
+			{"icc run", "Launch Claude Code with hooks and memory"},
+			{"icc install", "Set up project configuration"},
+			{"icc serve", "Standalone console server"},
+			{"icc info", "Show this capabilities reference"},
+			{"icc greet", "Print the welcome banner"},
+			{"icc worktree", "Git worktree management"},
+			{"icc session list", "List sessions"},
+			{"icc check-context", "Show current context usage"},
+			{"icc send-clear", "Send clear signal to session"},
+		},
+		Hooks: []InfoEntry{
+			{"file-checker", "Language-aware lint and format on file writes"},
+			{"tdd-enforcer", "Enforce test-first development order"},
+			{"branch-guard", "Prevent direct commits to main"},
+			{"context-monitor", "Track context usage, trigger Endless Mode"},
+			{"tool-redirect", "Block or redirect tool calls"},
+			{"spec-stop-guard", "Prevent premature stop during /spec"},
+			{"spec-plan-validator", "Validate plan file structure"},
+			{"spec-verify-validator", "Validate verification results"},
+			{"task-tracker", "Track task creation and updates"},
+			{"notify", "Desktop notifications on stop"},
+		},
+		MCPTools: []InfoEntry{
+			{"search", "Semantic search across observations"},
+			{"save_memory", "Save observations to persistent memory"},
+			{"timeline", "Get chronological observation context"},
+			{"get_observations", "Retrieve observations by filter"},
+		},
+		Skills: []InfoEntry{
+			{"/spec", "Plan, implement, and verify with TDD"},
+			{"/spec-plan", "Planning phase only"},
+			{"/spec-implement", "Implementation phase only"},
+			{"/spec-verify", "Verification phase only"},
+			{"/itkdev-issue-workflow", "Autonomous GitHub issue workflow"},
+		},
+	}
+}
+
+func init() {
+	rootCmd.AddCommand(infoCmd)
+}

internal/cli/info_test.go

@@ -0,0 +1,69 @@
+package cli
+
+import (
+	"bytes"
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+func TestInfoCommand(t *testing.T) {
+	jsonOutput = false // reset global flag from other tests
+	buf := new(bytes.Buffer)
+	rootCmd.SetOut(buf)
+	rootCmd.SetArgs([]string{"info"})
+
+	if err := rootCmd.Execute(); err != nil {
+		t.Fatalf("info command failed: %v", err)
+	}
+
+	output := buf.String()
+
+	sections := []string{"Features:", "Commands:", "Hooks:", "MCP Tools:", "Skills:"}
+	for _, section := range sections {
+		if !strings.Contains(output, section) {
+			t.Errorf("output missing section %q", section)
+		}
+	}
+
+	entries := []string{"file-checker", "icc run", "search", "/spec"}
+	for _, entry := range entries {
+		if !strings.Contains(output, entry) {
+			t.Errorf("output missing entry %q", entry)
+		}
+	}
+}
+
+func TestInfoCommandJSON(t *testing.T) {
+	buf := new(bytes.Buffer)
+	rootCmd.SetOut(buf)
+	rootCmd.SetArgs([]string{"info", "--json"})
+
+	if err := rootCmd.Execute(); err != nil {
+		t.Fatalf("info --json command failed: %v", err)
+	}
+
+	var data InfoData
+	if err := json.Unmarshal(buf.Bytes(), &data); err != nil {
+		t.Fatalf("invalid JSON output: %v", err)
+	}
+
+	if data.Name == "" {
+		t.Error("JSON name field is empty")
+	}
+	if data.Version == "" {
+		t.Error("JSON version field is empty")
+	}
+	if len(data.Features) == 0 {
+		t.Error("JSON features list is empty")
+	}
+	if len(data.Hooks) == 0 {
+		t.Error("JSON hooks list is empty")
+	}
+	if len(data.MCPTools) == 0 {
+		t.Error("JSON mcp_tools list is empty")
+	}
+	if len(data.Skills) == 0 {
+		t.Error("JSON skills list is empty")
+	}
+}

internal/cli/run.go

@@ -187,7 +187,7 @@ func updateSettingsAnnouncement(path string, port int, logger *slog.Logger) {
 	}
 
 	settings["companyAnnouncements"] = []string{
-		"Console: http://localhost:" + strconv.Itoa(port) + " | /spec — plan, build & verify",
+		"Console: http://localhost:" + strconv.Itoa(port) + " | /spec — plan, build & verify | Hooks: lint, TDD, branch-guard | Memory: save_memory, search | icc info — full reference",
 	}
 
 	out, err := json.MarshalIndent(settings, "", "  ")

internal/cli/run_test.go

@@ -42,7 +42,7 @@ func TestUpdateSettingsAnnouncement(t *testing.T) {
 			t.Fatalf("expected 1 announcement, got %v", result["companyAnnouncements"])
 		}
 
-		want := "Console: http://localhost:42000 | /spec — plan, build & verify"
+		want := "Console: http://localhost:42000 | /spec — plan, build & verify | Hooks: lint, TDD, branch-guard | Memory: save_memory, search | icc info — full reference"
 		if announcements[0] != want {
 			t.Errorf("announcement = %q, want %q", announcements[0], want)
 		}

internal/console/context/builder.go

@@ -75,6 +75,20 @@ func (b *Builder) Build(observations []*db.Observation, summaries []*db.Summary)
 		}
 	}
 
+	// Always append a capabilities summary so Claude knows what's available
+	capabilities := `## Active Features
+- **Quality Hooks**: file-checker (lint/format), tdd-enforcer, branch-guard (no commits to main)
+- **Context Management**: context-monitor with Endless Mode at 90%
+- **Persistent Memory**: save_memory() to record discoveries, search() to find them
+- **Workflows**: /spec (plan → implement → verify), /itkdev-issue-workflow
+- **Web Console**: observations, sessions, plans, search at the console URL
+- **Worktree Isolation**: icc worktree for safe parallel work`
+
+	capTokens := EstimateTokens(capabilities)
+	if usedTokens+capTokens <= b.maxTokens {
+		parts = append(parts, capabilities)
+	}
+
 	if len(parts) == 0 {
 		return ""
 	}

internal/console/context/builder_test.go

@@ -87,6 +87,41 @@ func TestBuildTruncatesToTokenBudget(t *testing.T) {
 	}
 }
 
+func TestBuildIncludesCapabilities(t *testing.T) {
+	b := NewBuilder(4000)
+
+	// Even with no observations or summaries, capabilities should not appear
+	// (the builder returns empty when both inputs are nil)
+	result := b.Build(nil, nil)
+	if result != "" {
+		t.Errorf("expected empty string for nil inputs, got %q", result)
+	}
+
+	// With observations, capabilities section should be appended
+	obs := []*db.Observation{
+		{ID: 1, Type: "discovery", Title: "Test", Text: "Test observation"},
+	}
+	result = b.Build(obs, nil)
+
+	if !containsAll(result, "Active Features", "Quality Hooks", "Persistent Memory", "/spec") {
+		t.Errorf("result missing capabilities section: %s", result)
+	}
+}
+
+func TestBuildCapabilitiesOmittedWhenBudgetTight(t *testing.T) {
+	b := NewBuilder(50) // very tight budget
+
+	obs := []*db.Observation{
+		{ID: 1, Type: "discovery", Title: "Important", Text: "Critical finding that takes up budget"},
+	}
+	result := b.Build(obs, nil)
+
+	// Capabilities should be omitted when budget is too tight
+	if containsAll(result, "Active Features") {
+		t.Error("capabilities should be omitted when token budget is tight")
+	}
+}
+
 func TestEstimateTokens(t *testing.T) {
 	tests := []struct {
 		input string

internal/installer/steps/config_files.go

@@ -125,12 +125,24 @@ func settingsJSON(binPath string) []byte {
 		"enableAllProjectMcpServers": true,
 		"respectGitignore":           false,
 		"alwaysThinkingEnabled":      true,
-		"spinnerTipsEnabled":         false,
-		"prefersReducedMotion":       true,
-		"showTurnDuration":           false,
-		"cleanupPeriodDays":          7,
+		"spinnerTipsEnabled":         true,
+		"spinnerTips": []string{
+			"Use save_memory() to record important discoveries for future sessions",
+			"/spec guides you through plan → implement → verify with TDD",
+			"The web console tracks all observations, sessions, and plans",
+			"Context monitor triggers Endless Mode at 90% — no manual intervention needed",
+			"Branch guard prevents accidental commits to main",
+			"File checker runs lint and format automatically on every file write",
+			"Use icc info to see all available features, hooks, and tools",
+			"Worktree isolation lets you work on multiple branches safely in parallel",
+			"Search across all observations with the search MCP tool",
+			"TDD enforcer ensures tests are written before implementation",
+		},
+		"prefersReducedMotion": true,
+		"showTurnDuration":     false,
+		"cleanupPeriodDays":    7,
 		"companyAnnouncements": []string{
-			"Console: http://localhost:" + strconv.Itoa(config.DefaultPort) + " | /spec — plan, build & verify",
+			"Console: http://localhost:" + strconv.Itoa(config.DefaultPort) + " | /spec — plan, build & verify | Hooks: lint, TDD, branch-guard | Memory: save_memory, search | icc info — full reference",
 		},
 	}
 	data, _ := json.MarshalIndent(settings, "", "  ")