fix(wfctl): remove database-to-sqlite modernize rule

Generic database functionality should be provider-agnostic rather than
recommending SQLite-specific patterns. Add design and plan docs.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: intel352

cmd/wfctl/modernize_rules.go

@@ -15,7 +15,6 @@ func allModernizeRules() []Rule {
 		conditionalFieldRule(),
 		dbQueryModeRule(),
 		dbQueryIndexRule(),
-		databaseToSqliteRule(),
 		absoluteDbPathRule(),
 		emptyRoutesRule(),
 		camelCaseConfigRule(),
@@ -501,86 +500,3 @@ func camelCaseConfigRule() Rule {
 	}
 }
 
-func databaseToSqliteRule() Rule {
-	return Rule{
-		ID:          "database-to-sqlite",
-		Description: "Convert database.workflow modules to storage.sqlite",
-		Severity:    "warning",
-		Check: func(root *yaml.Node, raw []byte) []Finding {
-			var findings []Finding
-			forEachModule(root, func(mod *yaml.Node) {
-				typeNode := findMapValue(mod, "type")
-				if typeNode != nil && typeNode.Value == "database.workflow" {
-					nameNode := findMapValue(mod, "name")
-					name := ""
-					if nameNode != nil {
-						name = nameNode.Value
-					}
-					findings = append(findings, Finding{
-						RuleID:  "database-to-sqlite",
-						Line:    typeNode.Line,
-						Message: fmt.Sprintf("Module %q uses database.workflow (use storage.sqlite instead)", name),
-						Fixable: true,
-					})
-				}
-			})
-			return findings
-		},
-		Fix: func(root *yaml.Node) []Change {
-			var changes []Change
-			forEachModule(root, func(mod *yaml.Node) {
-				typeNode := findMapValue(mod, "type")
-				if typeNode == nil || typeNode.Value != "database.workflow" {
-					return
-				}
-				nameNode := findMapValue(mod, "name")
-				name := "unknown"
-				if nameNode != nil {
-					name = nameNode.Value
-				}
-
-				// Change type
-				typeNode.Value = "storage.sqlite"
-
-				// Rebuild config: extract DSN to derive dbPath
-				cfg := findMapValue(mod, "config")
-				if cfg == nil || cfg.Kind != yaml.MappingNode {
-					cfg = &yaml.Node{Kind: yaml.MappingNode}
-					mod.Content = append(mod.Content,
-						&yaml.Node{Kind: yaml.ScalarNode, Value: "config"},
-						cfg,
-					)
-				}
-
-				// Try to extract filename from DSN
-				dbPath := name + ".db"
-				dsnNode := findMapValue(cfg, "dsn")
-				if dsnNode != nil {
-					dsn := dsnNode.Value
-					dsn = strings.TrimPrefix(dsn, "file:")
-					dsn = strings.Split(dsn, "?")[0]
-					if dsn != "" {
-						dbPath = dsn
-					}
-				}
-
-				// Replace config contents with storage.sqlite config
-				cfg.Content = []*yaml.Node{
-					{Kind: yaml.ScalarNode, Value: "dbPath"},
-					{Kind: yaml.ScalarNode, Value: dbPath},
-					{Kind: yaml.ScalarNode, Value: "maxConnections"},
-					{Kind: yaml.ScalarNode, Value: "5"},
-					{Kind: yaml.ScalarNode, Value: "walMode"},
-					{Kind: yaml.ScalarNode, Value: "true", Tag: "!!bool"},
-				}
-
-				changes = append(changes, Change{
-					RuleID:      "database-to-sqlite",
-					Line:        typeNode.Line,
-					Description: fmt.Sprintf("Converted module %q from database.workflow to storage.sqlite (dbPath: %s)", name, dbPath),
-				})
-			})
-			return changes
-		},
-	}
-}

cmd/wfctl/modernize_test.go

@@ -404,57 +404,6 @@ pipelines:
 	}
 }
 
-func TestDatabaseToSqliteCheck(t *testing.T) {
-	input := `
-modules:
-  - name: my-db
-    type: database.workflow
-    config:
-      driver: sqlite
-      dsn: "file:data.db"
-`
-	rule := findRule("database-to-sqlite")
-	if rule == nil {
-		t.Fatal("database-to-sqlite rule not found")
-	}
-
-	doc := parseTestYAML(t, input)
-	findings := rule.Check(doc, []byte(input))
-	if len(findings) == 0 {
-		t.Fatal("expected findings for database.workflow")
-	}
-}
-
-func TestDatabaseToSqliteFix(t *testing.T) {
-	input := `
-modules:
-  - name: my-db
-    type: database.workflow
-    config:
-      driver: sqlite
-      dsn: "file:data.db"
-`
-	rule := findRule("database-to-sqlite")
-	doc := parseTestYAML(t, input)
-	changes := rule.Fix(doc)
-	if len(changes) == 0 {
-		t.Fatal("expected changes from fix")
-	}
-
-	out, _ := yaml.Marshal(doc)
-	result := string(out)
-
-	if strings.Contains(result, "database.workflow") {
-		t.Errorf("expected type to be changed, got:\n%s", result)
-	}
-	if !strings.Contains(result, "storage.sqlite") {
-		t.Errorf("expected storage.sqlite type, got:\n%s", result)
-	}
-	if !strings.Contains(result, "dbPath") {
-		t.Errorf("expected dbPath in config, got:\n%s", result)
-	}
-}
-
 func TestAbsoluteDbPathCheck(t *testing.T) {
 	input := `
 modules:
@@ -540,7 +489,6 @@ func TestModernizeAllRulesRegistered(t *testing.T) {
 		"conditional-field",
 		"db-query-mode",
 		"db-query-index",
-		"database-to-sqlite",
 		"absolute-dbpath",
 		"empty-routes",
 		"camelcase-config",
@@ -579,12 +527,6 @@ func TestModernizeFullPipeline(t *testing.T) {
 	// A config with multiple issues
 	input := `
 name: test-app
-modules:
-  - name: my-db
-    type: database.workflow
-    config:
-      driver: sqlite
-      dsn: "file:app.db"
 pipelines:
   check:
     steps:
@@ -643,9 +585,6 @@ pipelines:
 	if strings.Contains(result, "check-input") {
 		t.Error("hyphen-steps: check-input not renamed")
 	}
-	if strings.Contains(result, "database.workflow") {
-		t.Error("database-to-sqlite: type not changed")
-	}
 	if strings.Contains(result, `field: "{{ .steps`) {
 		t.Error("conditional-field: template not converted")
 	}

docs/plans/2026-03-08-wfctl-modernize-design.md

@@ -0,0 +1,108 @@
+# wfctl modernize — YAML Config Codemod Tool
+
+## Problem
+
+Users encounter runtime errors from known YAML config anti-patterns that could be detected and fixed automatically. During scenario testing, 8+ recurring issues were identified that require manual debugging and fixing. A codemod tool eliminates this toil.
+
+## Command Interface
+
+```
+wfctl modernize [options] <config.yaml|directory>
+wfctl modernize --list-rules
+wfctl modernize --dry-run config/app.yaml          # default: show what would change
+wfctl modernize --apply config/app.yaml             # write changes in-place
+wfctl modernize --rules hyphen-steps,conditional-field config/app.yaml
+wfctl modernize --exclude-rules validate-syntax config/app.yaml
+```
+
+Dry-run is the default. `--apply` writes changes in-place (git is the backup).
+
+## Rules
+
+| Rule ID | Description | Severity | Fixable |
+|---------|-------------|----------|---------|
+| `hyphen-steps` | Rename hyphenated step names to underscores, update all references | error | yes |
+| `conditional-field` | Convert `{{ }}` template syntax in `step.conditional` field to dot-path | error | yes |
+| `db-query-mode` | Add `mode: single` to `step.db_query` steps whose downstream templates use `.row` or `.found` | warning | yes |
+| `db-query-index` | Convert `.steps.X.row.Y` dot-access to `index .steps "X" "row" "Y"` in templates | error | yes |
+| `database-to-sqlite` | Convert `database.workflow` modules to `storage.sqlite` with `dbPath` | warning | yes |
+| `absolute-dbpath` | Warn on absolute `dbPath` values in `storage.sqlite` | warning | no |
+| `empty-routes` | Detect empty `routes` map in `step.conditional` | error | no |
+| `camelcase-config` | Detect snake_case config field names (engine requires camelCase) | warning | no |
+
+## Architecture
+
+### AST-Based Transformations
+
+Uses `yaml.Node` (gopkg.in/yaml.v3) for parsing and rewriting. This preserves comments, formatting, and ordering — critical for config files users maintain by hand. The LSP already uses `yaml.Node` for diagnostics, so this pattern is established.
+
+### Rule Interface
+
+```go
+type Rule struct {
+    ID          string
+    Description string
+    Severity    string // "error" or "warning"
+    Check       func(root *yaml.Node, cfg *config.WorkflowConfig) []Finding
+    Fix         func(root *yaml.Node) []Change
+}
+
+type Finding struct {
+    RuleID  string
+    Line    int
+    Column  int
+    Message string
+    Fixable bool
+}
+
+type Change struct {
+    RuleID      string
+    Line        int
+    Description string
+}
+```
+
+- `Check()` always runs — detects issues and reports findings
+- `Fix()` only runs with `--apply` — mutates the `yaml.Node` AST
+- After all fixes, the modified AST is marshaled back to the file
+
+### Output Format
+
+**Dry-run (default):**
+```
+config/app.yaml:
+  line 12: [hyphen-steps] Step "check-xss" uses hyphens (fixable)
+  line 45: [conditional-field] step.conditional field uses template syntax (fixable)
+  line 78: [db-query-mode] step.db_query missing mode:single, downstream uses .row (fixable)
+
+3 issues found (3 fixable). Run with --apply to fix.
+```
+
+**Apply mode:**
+```
+config/app.yaml:
+  line 12: [hyphen-steps] Renamed "check-xss" -> "check_xss" (+ 3 references)
+  line 45: [conditional-field] Converted field to dot-path syntax
+  line 78: [db-query-mode] Added mode: single
+
+3 fixes applied.
+```
+
+Supports `--format json` for CI integration.
+
+## Files
+
+| File | Purpose |
+|------|---------|
+| `cmd/wfctl/modernize.go` | Command entry, flag parsing, orchestration, AST helpers |
+| `cmd/wfctl/modernize_rules.go` | All rule implementations |
+| `cmd/wfctl/modernize_test.go` | Tests with inline YAML fixtures |
+
+## Key Decisions
+
+- **Dry-run by default** — safe; user must opt in with `--apply`
+- **AST-based** — `yaml.Node` preserves comments and formatting better than unmarshal/marshal round-trips
+- **Rules are data-driven** — each rule is a struct with check/fix functions, easy to add new rules
+- **Directory scanning** — reuses existing `findYAMLFiles()` helper from wfctl
+- **No backup files** — git is the backup
+- **Follows existing wfctl patterns** — `flag.FlagSet`, `reorderFlags()`, same file conventions