feat: add import summary

Author: xinnjie

docs/design.md

@@ -7,20 +7,8 @@ The `OneKeymap` app is a cross-platform desktop application that enables users t
 ### Supported Editors
 
 **VSCode Family:**
-- VSCode
-- Windsurf
-- Windsurf Next
-- Cursor
 
 **IntelliJ Family:**
-- IntelliJ IDEA (Ultimate & Community)
-- PyCharm
-- WebStorm
-- CLion
-- PhpStorm
-- RubyMine
-- GoLand
-- RustRover
 
 **Other Editors:**
 - Zed

docs/export_diff.md docs/export_report.mddocs/export_diff.md renamed to docs/export_report.md

@@ -1,13 +1,15 @@
 package cmd
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
 	"io"
 	"log/slog"
 	"os"
 	"path/filepath"
 	"strings"
+	"text/template"
 
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/spf13/cobra"
@@ -145,25 +147,11 @@ func executeImportInteractive(
 		return err
 	}
 
-	if result != nil && len(result.SkipReport.SkipActions) > 0 {
-		vm := views.NewImportSkipReportViewModel(result.SkipReport)
-		p := tea.NewProgram(vm)
-		if _, err := p.Run(); err != nil {
-			logger.Error("could not start program", "error", err)
-		}
+	if result != nil {
+		printImportSummary(cmd, result)
 	}
 
-	// Show validation report if there are issues
-	if result != nil && result.Report != nil &&
-		(len(result.Report.Issues) > 0 || len(result.Report.Warnings) > 0) {
-		logger.Info("Validation found issues. Displaying report...")
-		if err := runValidationReportPreview(result.Report); err != nil {
-			logger.Warn("Failed to display validation report", "error", err)
-		}
-	}
-
-	// Show changes preview and get user confirmation
-	if result != nil && result.Changes != nil {
+	if result.Changes.HasChanges() {
 		confirmed, err := runImportChangesPreview(result.Changes)
 		if err != nil {
 			logger.Warn("failed to render changes preview", "error", err)
@@ -172,6 +160,8 @@ func executeImportInteractive(
 			logger.Info("User cancelled applying changes; no file will be written")
 			return nil
 		}
+	} else {
+		cmd.Println("No changes to import - file will not be updated")
 	}
 
 	return saveImportResult(f.output, result, logger)
@@ -217,6 +207,10 @@ func executeImportNonInteractive(
 		return err
 	}
 
+	if result != nil {
+		printImportSummary(cmd, result)
+	}
+
 	return saveImportResult(f.output, result, logger)
 }
 
@@ -278,6 +272,163 @@ func saveImportResult(outputPath string, result *importerapi.ImportResult, logge
 	return nil
 }
 
+type importSkippedView struct {
+	Action          string
+	KeybindingCount int
+	Reason          string
+}
+
+type importSummaryView struct {
+	TotalImported     int
+	Skipped           []importSkippedView
+	HasValidation     bool
+	ValidationSource  string
+	MappingsProcessed int
+	MappingsSucceeded int
+	Issues            []string
+	Warnings          []string
+}
+
+// nolint: gochecknoglobals
+var importSummaryTemplate = template.Must(template.New("importSummary").Parse(`
+Import Summary:
+  ✓ {{ .TotalImported }} actions imported into onekeymap
+{{- $skippedCount := len .Skipped }}
+{{- if eq $skippedCount 0 }}
+  ✗ 0 editor actions skipped
+{{- else }}
+  ✗ {{ $skippedCount }} editor actions skipped:
+{{- range .Skipped }}
+    - {{ .Action }}{{ if gt .KeybindingCount 0 }} ({{ .KeybindingCount }} keybindings){{ end }}{{ if .Reason }}: {{ .Reason }}{{ end }}
+{{- end }}
+{{- end }}
+{{- if .HasValidation }}
+
+Validation Summary:
+  Source: {{ .ValidationSource }} | Mappings Processed: {{ .MappingsProcessed }} | Succeeded: {{ .MappingsSucceeded }}
+  Issues: {{ len .Issues }}, Warnings: {{ len .Warnings }}
+{{- if gt (len .Issues) 0 }}
+  Issues ({{ len .Issues }}):
+{{- range .Issues }}
+    - {{ . }}
+{{- end }}
+{{- end }}
+{{- if gt (len .Warnings) 0 }}
+  Warnings ({{ len .Warnings }}):
+{{- range .Warnings }}
+    - {{ . }}
+{{- end }}
+{{- end }}
+{{- end }}
+`))
+
+func printImportSummary(cmd *cobra.Command, result *importerapi.ImportResult) {
+	view := importSummaryView{
+		TotalImported: len(result.Setting.Actions),
+	}
+
+	for _, sk := range result.SkipReport.SkipActions {
+		item := importSkippedView{
+			Action:          sk.EditorSpecificAction,
+			KeybindingCount: len(sk.Keybindings),
+		}
+		if sk.Error != nil {
+			item.Reason = sk.Error.Error()
+		}
+		view.Skipped = append(view.Skipped, item)
+	}
+
+	if result.Report != nil {
+		rep := result.Report
+		view.HasValidation = true
+		view.ValidationSource = rep.SourceEditor
+		view.MappingsProcessed = rep.Summary.MappingsProcessed
+		view.MappingsSucceeded = rep.Summary.MappingsSucceeded
+		for _, issue := range rep.Issues {
+			view.Issues = append(view.Issues, renderValidationIssueInline(issue))
+		}
+		for _, warning := range rep.Warnings {
+			view.Warnings = append(view.Warnings, renderValidationIssueInline(warning))
+		}
+	}
+
+	var buf bytes.Buffer
+	if err := importSummaryTemplate.Execute(&buf, view); err != nil {
+		// Fallback to minimal output if template rendering fails
+		cmd.Println()
+		cmd.Println("Import Summary:")
+		cmd.Printf("  ✓ %d actions imported into onekeymap\n", view.TotalImported)
+		return
+	}
+
+	cmd.Println()
+	cmd.Print(buf.String())
+}
+
+// renderValidationIssueInline renders a single validation issue in a compact textual form,
+// mirroring the semantics of views.renderIssue but without TUI styling.
+func renderValidationIssueInline(issue validateapi.ValidationIssue) string {
+	switch issue.Type {
+	case validateapi.IssueTypeKeybindConflict:
+		if c, ok := issue.Details.(validateapi.KeybindConflict); ok {
+			var actionLines []string
+			for _, action := range c.Actions {
+				if action.Context != "" {
+					actionLines = append(actionLines, fmt.Sprintf("%s (%s)", action.Context, action.ActionID))
+				} else {
+					actionLines = append(actionLines, action.ActionID)
+				}
+			}
+			return fmt.Sprintf(
+				"Keybind Conflict: %s is mapped to multiple actions:\n      - %s",
+				c.Keybinding,
+				strings.Join(actionLines, "\n      - "),
+			)
+		}
+	case validateapi.IssueTypeDanglingAction:
+		if d, ok := issue.Details.(validateapi.DanglingAction); ok {
+			suggestion := ""
+			if d.Suggestion != "" {
+				suggestion = fmt.Sprintf(" (%s)", d.Suggestion)
+			}
+			return fmt.Sprintf(
+				"Dangling Action: %s does not exist in target %s.%s",
+				d.Action,
+				d.TargetEditor,
+				suggestion,
+			)
+		}
+	case validateapi.IssueTypeUnsupportedAction:
+		if u, ok := issue.Details.(validateapi.UnsupportedAction); ok {
+			return fmt.Sprintf(
+				"Unsupported Action: %s (on key %s) is not supported for target %s.",
+				u.Action,
+				u.Keybinding,
+				u.TargetEditor,
+			)
+		}
+	case validateapi.IssueTypeDuplicateMapping:
+		if d, ok := issue.Details.(validateapi.DuplicateMapping); ok {
+			return fmt.Sprintf(
+				"Duplicate Mapping: Action %s with key %s is defined multiple times.",
+				d.Action,
+				d.Keybinding,
+			)
+		}
+	case validateapi.IssueTypePotentialShadowing:
+		if p, ok := issue.Details.(validateapi.PotentialShadowing); ok {
+			return fmt.Sprintf(
+				"Potential Shadowing: Key %s (for action %s). %s",
+				p.Keybinding,
+				p.Action,
+				p.CriticalShortcutDescription,
+			)
+		}
+	}
+
+	return "Unknown issue type."
+}
+
 func handleInteractiveImportFlags(
 	cmd *cobra.Command,
 	f *importFlags,
@@ -415,13 +566,3 @@ func runImportForm(
 	}
 	return nil
 }
-
-// run the validation report TUI ---.
-func runValidationReportPreview(report *validateapi.ValidationReport) error {
-	m := views.NewValidationReportModel(report)
-	p := tea.NewProgram(m)
-	if _, err := p.Run(); err != nil {
-		return err
-	}
-	return nil
-}

internal/cmd/import.go

@@ -1,31 +1,63 @@
 package imports
 
 import (
+	"github.com/xinnjie/onekeymap-cli/pkg/api/keymap/keybinding"
 	"github.com/xinnjie/onekeymap-cli/pkg/api/pluginapi"
 )
 
 type Marker struct {
 	imported map[string]bool
-	skipped  map[string]error
+	skipped  map[string]skippedEntry
 	order    []string
+
+	// importedResults tracks detailed import results keyed by "mappedAction:editorAction"
+	importedResults map[string]*pluginapi.KeybindingImportResult
+	importedOrder   []string
+}
+
+type skippedEntry struct {
+	err         error
+	keybindings []keybinding.Keybinding
 }
 
 func NewMarker() *Marker {
 	return &Marker{
-		imported: make(map[string]bool),
-		skipped:  make(map[string]error),
+		imported:        make(map[string]bool),
+		skipped:         make(map[string]skippedEntry),
+		importedResults: make(map[string]*pluginapi.KeybindingImportResult),
 	}
 }
 
-func (m *Marker) MarkImported(editorSpecificAction string) {
-	if editorSpecificAction == "" {
+// MarkImported records a successful import with full details for coverage reporting.
+func (m *Marker) MarkImported(
+	mappedAction string,
+	editorSpecificAction string,
+	originalKeybinding keybinding.Keybinding,
+	importedKeybinding keybinding.Keybinding,
+) {
+	if mappedAction == "" || editorSpecificAction == "" {
 		return
 	}
+	// mark as imported and clear any previous skipped entry
 	m.imported[editorSpecificAction] = true
 	delete(m.skipped, editorSpecificAction)
+
+	key := mappedAction + "\x00" + editorSpecificAction
+	result, exists := m.importedResults[key]
+	if !exists {
+		result = &pluginapi.KeybindingImportResult{
+			MappedAction:         mappedAction,
+			EditorSpecificAction: editorSpecificAction,
+		}
+		m.importedResults[key] = result
+		m.importedOrder = append(m.importedOrder, key)
+	}
+	result.OriginalKeybindings = append(result.OriginalKeybindings, originalKeybinding)
+	result.ImportedKeybindings = append(result.ImportedKeybindings, importedKeybinding)
 }
 
-func (m *Marker) MarkSkippedForReason(editorSpecificAction string, reasonErr error) {
+// MarkSkipped records a skipped action with its keybinding for coverage reporting.
+func (m *Marker) MarkSkipped(editorSpecificAction string, kb *keybinding.Keybinding, reasonErr error) {
 	if editorSpecificAction == "" {
 		return
 	}
@@ -35,10 +67,15 @@ func (m *Marker) MarkSkippedForReason(editorSpecificAction string, reasonErr err
 	if m.imported[editorSpecificAction] {
 		return
 	}
-	if _, exists := m.skipped[editorSpecificAction]; !exists {
-		m.skipped[editorSpecificAction] = reasonErr
+	entry, exists := m.skipped[editorSpecificAction]
+	if !exists {
+		entry = skippedEntry{err: reasonErr}
 		m.order = append(m.order, editorSpecificAction)
 	}
+	if kb != nil {
+		entry.keybindings = append(entry.keybindings, *kb)
+	}
+	m.skipped[editorSpecificAction] = entry
 }
 
 func (m *Marker) Report() pluginapi.ImportSkipReport {
@@ -47,12 +84,24 @@ func (m *Marker) Report() pluginapi.ImportSkipReport {
 		if m.imported[action] {
 			continue
 		}
-		if err, ok := m.skipped[action]; ok {
+		if entry, ok := m.skipped[action]; ok {
 			result = append(result, pluginapi.ImportSkipAction{
 				EditorSpecificAction: action,
-				Error:                err,
+				Keybindings:          entry.keybindings,
+				Error:                entry.err,
 			})
 		}
 	}
 	return pluginapi.ImportSkipReport{SkipActions: result}
 }
+
+// ImportedReport returns the detailed import results for coverage reporting.
+func (m *Marker) ImportedReport() pluginapi.ImportedReport {
+	results := make([]pluginapi.KeybindingImportResult, 0, len(m.importedResults))
+	for _, key := range m.importedOrder {
+		if result, ok := m.importedResults[key]; ok {
+			results = append(results, *result)
+		}
+	}
+	return pluginapi.ImportedReport{Results: results}
+}