fix: forgot cmd

Signed-off-by: Dennis Zhuang <killme2008@gmail.com>

Author: killme2008

.gitignore

@@ -1,5 +1,5 @@
 # Build output
-devtap
+/devtap
 dist/
 
 # devtap adapter configs

README.md

@@ -174,6 +174,19 @@ devtap --tag cargo-test --debounce 5s -- cargo watch -x test
 2. Project marker files (nearest parent with one of: `go.mod`, `package.json`, `pyproject.toml`, `Cargo.toml`, `pom.xml`, `build.gradle`, `build.gradle.kts`, `composer.json`, `Gemfile`, `setup.py`)
 3. Current working directory
 
+**Chaining commands** — `devtap` captures a single command after `--`. If you need shell operators like `&&`, wrap the command in a shell:
+
+```bash
+devtap -- sh -c "npm install && npm run dev"
+```
+
+Or run them separately:
+
+```bash
+devtap -- npm install
+devtap -- npm run dev
+```
+
 ## CLI Reference
 
 ```

cmd/devtap/drain.go

@@ -0,0 +1,150 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/spf13/cobra"
+
+	"github.com/killme2008/devtap/internal/mcp"
+	"github.com/killme2008/devtap/internal/store"
+	greptimestore "github.com/killme2008/devtap/internal/store/greptimedb"
+)
+
+func drainCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "drain",
+		Short: "Consume pending messages and output plain text",
+		Long: `Read pending build output and print it as plain text.
+
+Used by lint wrapper scripts (aider) and the Stop hook (auto-loop).
+For MCP-capable tools, use "devtap mcp-serve" instead.`,
+		SilenceUsage: true,
+		RunE:         runDrain,
+	}
+
+	cmd.Flags().String("event", "", "hook event name (only needed for Stop auto-loop)")
+	cmd.Flags().Bool("auto-loop", false, "enable auto-loop mode (block Stop if errors pending)")
+	cmd.Flags().Int("max-retries", 5, "max retries for auto-loop")
+	cmd.Flags().Int("max-lines", 10000, "max lines to drain")
+	cmd.Flags().String("filter-sql", "", "SQL WHERE clause for GreptimeDB filtering")
+
+	return cmd
+}
+
+func runDrain(cmd *cobra.Command, args []string) error {
+	adapterName, _ := cmd.Flags().GetString("adapter")
+	sessionFlag, _ := cmd.Flags().GetString("session")
+	event, _ := cmd.Flags().GetString("event")
+	autoLoop, _ := cmd.Flags().GetBool("auto-loop")
+	maxRetries, _ := cmd.Flags().GetInt("max-retries")
+	maxLines, _ := cmd.Flags().GetInt("max-lines")
+	filterSQL, _ := cmd.Flags().GetString("filter-sql")
+
+	sessionID, err := resolveSession(adapterName, sessionFlag)
+	if err != nil {
+		return fmt.Errorf("resolve session: %w", err)
+	}
+
+	s, err := openStore(cmd)
+	if err != nil {
+		return fmt.Errorf("create store: %w", err)
+	}
+	defer func() { _ = s.Close() }()
+
+	// Drain messages (with SQL filter if using GreptimeDB)
+	var messages []store.LogMessage
+	if filterSQL != "" {
+		if gs, ok := s.(*greptimestore.Store); ok {
+			messages, err = gs.DrainSQL(sessionID, filterSQL, maxLines)
+		} else {
+			return fmt.Errorf("--filter-sql requires --store greptimedb")
+		}
+	} else {
+		messages, err = s.Drain(sessionID, maxLines)
+	}
+	if err != nil {
+		return fmt.Errorf("drain: %w", err)
+	}
+
+	messages = mcp.TruncateMessages(messages, maxLines)
+
+	// Handle auto-loop Stop hook (Claude Code specific)
+	if event == "Stop" && autoLoop {
+		storeDir, err := defaultStoreDir()
+		if err != nil {
+			return fmt.Errorf("resolve store dir: %w", err)
+		}
+		return handleAutoLoopStop(storeDir, sessionID, messages, maxRetries)
+	}
+
+	// Reset retry counter on any non-Stop drain (e.g., user submitted a new prompt).
+	if event != "" && event != "Stop" {
+		if storeDir, err := defaultStoreDir(); err == nil {
+			tracker := store.NewRetryTracker(storeDir)
+			_ = tracker.Reset(sessionID)
+		}
+	}
+
+	if len(messages) == 0 {
+		return nil
+	}
+
+	// Plain text output
+	fmt.Println(mcp.FormatMessages(messages))
+	return nil
+}
+
+func handleAutoLoopStop(storeDir, sessionID string, messages []store.LogMessage, maxRetries int) error {
+	hasErrors := false
+	for _, msg := range messages {
+		if msg.ExitCode != nil && *msg.ExitCode != 0 {
+			hasErrors = true
+			break
+		}
+	}
+
+	if !hasErrors || len(messages) == 0 {
+		// No errors — allow Claude to stop
+		fmt.Print("{}")
+		return nil
+	}
+
+	tracker := store.NewRetryTracker(storeDir)
+	count, err := tracker.Get(sessionID)
+	if err != nil {
+		return fmt.Errorf("get retry count: %w", err)
+	}
+
+	if count >= maxRetries {
+		// Exceeded retry limit — allow stop
+		fmt.Print("{}")
+		return nil
+	}
+
+	newCount, err := tracker.Increment(sessionID)
+	if err != nil {
+		return fmt.Errorf("increment retry count: %w", err)
+	}
+
+	// Annotate tags with attempt info
+	for i := range messages {
+		tag := messages[i].Tag
+		if tag == "" {
+			tag = "build"
+		}
+		messages[i].Tag = fmt.Sprintf("%s (attempt %d/%d)", tag, newCount, maxRetries)
+	}
+
+	reason := mcp.FormatMessages(messages)
+	output, err := json.Marshal(map[string]any{
+		"decision": "block",
+		"reason":   reason,
+	})
+	if err != nil {
+		return fmt.Errorf("marshal stop response: %w", err)
+	}
+
+	fmt.Print(string(output))
+	return nil
+}

cmd/devtap/drain_test.go

@@ -0,0 +1,207 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/killme2008/devtap/internal/mcp"
+	"github.com/killme2008/devtap/internal/store"
+)
+
+func TestTruncateMessagesNoTruncation(t *testing.T) {
+	messages := []store.LogMessage{
+		{Tag: "a", Lines: []string{"line1", "line2"}},
+		{Tag: "b", Lines: []string{"line3"}},
+	}
+	result := mcp.TruncateMessages(messages, 10)
+	if len(result) != 2 {
+		t.Fatalf("expected 2 messages, got %d", len(result))
+	}
+	if len(result[0].Lines) != 2 || len(result[1].Lines) != 1 {
+		t.Error("lines should be unchanged when under limit")
+	}
+}
+
+func TestTruncateMessagesTruncates(t *testing.T) {
+	// Create 2 messages with 60 lines each = 120 total, truncate to 20.
+	lines1 := make([]string, 60)
+	lines2 := make([]string, 60)
+	for i := range lines1 {
+		lines1[i] = "msg1-line"
+		lines2[i] = "msg2-line"
+	}
+
+	messages := []store.LogMessage{
+		{Tag: "a", Lines: lines1},
+		{Tag: "b", Lines: lines2},
+	}
+	result := mcp.TruncateMessages(messages, 20)
+
+	// Both messages should be present with truncated lines.
+	totalLines := 0
+	for _, msg := range result {
+		totalLines += len(msg.Lines)
+	}
+	if totalLines > 20 {
+		t.Errorf("total lines %d should not exceed max 20", totalLines)
+	}
+
+	// Both messages should have lines (proportional allocation).
+	if len(result[0].Lines) == 0 {
+		t.Error("first message should have lines after truncation")
+	}
+	if len(result[1].Lines) == 0 {
+		t.Error("second message should have lines after truncation")
+	}
+
+	// Tags should be preserved.
+	if result[0].Tag != "a" || result[1].Tag != "b" {
+		t.Error("tags should be preserved")
+	}
+}
+
+func TestTruncateMessagesPreservesEmptyLines(t *testing.T) {
+	messages := []store.LogMessage{
+		{Tag: "a", Lines: []string{"line1"}},
+		{Tag: "b"},
+		{Tag: "c", Lines: []string{"line2"}},
+	}
+	result := mcp.TruncateMessages(messages, 10)
+	if len(result) != 3 {
+		t.Fatalf("expected 3 messages, got %d", len(result))
+	}
+	if result[1].Lines != nil {
+		t.Error("empty message should remain empty")
+	}
+}
+
+func TestTruncateMessagesZeroMaxLines(t *testing.T) {
+	messages := []store.LogMessage{
+		{Tag: "a", Lines: []string{"line1"}},
+	}
+	result := mcp.TruncateMessages(messages, 0)
+	if len(result) != 1 || len(result[0].Lines) != 1 {
+		t.Error("maxLines=0 should skip truncation")
+	}
+}
+
+func TestHandleAutoLoopStopNoErrors(t *testing.T) {
+	dir := t.TempDir()
+	exitCode := 0
+	messages := []store.LogMessage{
+		{Tag: "build", ExitCode: &exitCode},
+	}
+
+	// Capture stdout
+	old := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	err := handleAutoLoopStop(dir, "test-session", messages, 5)
+
+	_ = w.Close()
+	os.Stdout = old
+
+	if err != nil {
+		t.Fatalf("handleAutoLoopStop: %v", err)
+	}
+
+	buf := make([]byte, 1024)
+	n, _ := r.Read(buf)
+	output := string(buf[:n])
+	if output != "{}" {
+		t.Errorf("expected '{}' for no errors, got %q", output)
+	}
+}
+
+func TestHandleAutoLoopStopWithErrors(t *testing.T) {
+	dir := t.TempDir()
+	_ = os.MkdirAll(filepath.Join(dir, "test-session"), 0o755)
+
+	exitCode := 1
+	messages := []store.LogMessage{
+		{Tag: "build", Lines: []string{"error: something failed"}, ExitCode: &exitCode},
+	}
+
+	old := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	err := handleAutoLoopStop(dir, "test-session", messages, 5)
+
+	_ = w.Close()
+	os.Stdout = old
+
+	if err != nil {
+		t.Fatalf("handleAutoLoopStop: %v", err)
+	}
+
+	buf := make([]byte, 4096)
+	n, _ := r.Read(buf)
+	output := string(buf[:n])
+
+	if output == "{}" {
+		t.Error("should block when errors present")
+	}
+	// Should contain "block" decision
+	if !contains(output, "block") {
+		t.Errorf("output should contain 'block' decision, got %q", output)
+	}
+}
+
+func TestHandleAutoLoopStopExceedsRetries(t *testing.T) {
+	dir := t.TempDir()
+	sessionID := "test-session"
+	_ = os.MkdirAll(filepath.Join(dir, sessionID), 0o755)
+
+	exitCode := 1
+	messages := []store.LogMessage{
+		{Tag: "build", Lines: []string{"error"}, ExitCode: &exitCode},
+	}
+
+	// Exhaust retries.
+	maxRetries := 2
+	for i := 0; i < maxRetries; i++ {
+		old := os.Stdout
+		_, w, _ := os.Pipe()
+		os.Stdout = w
+		_ = handleAutoLoopStop(dir, sessionID, messages, maxRetries)
+		_ = w.Close()
+		os.Stdout = old
+	}
+
+	// Next call should allow stop (return "{}").
+	old := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	err := handleAutoLoopStop(dir, sessionID, messages, maxRetries)
+
+	_ = w.Close()
+	os.Stdout = old
+
+	if err != nil {
+		t.Fatalf("handleAutoLoopStop: %v", err)
+	}
+
+	buf := make([]byte, 1024)
+	n, _ := r.Read(buf)
+	output := string(buf[:n])
+	if output != "{}" {
+		t.Errorf("expected '{}' after exhausting retries, got %q", output)
+	}
+}
+
+func contains(s, substr string) bool {
+	return len(s) >= len(substr) && (s == substr || len(s) > 0 && containsSubstr(s, substr))
+}
+
+func containsSubstr(s, substr string) bool {
+	for i := 0; i <= len(s)-len(substr); i++ {
+		if s[i:i+len(substr)] == substr {
+			return true
+		}
+	}
+	return false
+}