feat(lint): separate generated rule state from policy

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

Author: tae2089

internal/cli/lint.go

@@ -2,12 +2,15 @@ package cli
 
 import (
 	"fmt"
+	"os"
 	"path/filepath"
 	"regexp"
+	"reflect"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"github.com/tae2089/trace"
+	"go.yaml.in/yaml/v3"
 
 	"github.com/tae2089/code-context-graph/internal/docs"
 	"github.com/tae2089/code-context-graph/internal/pathutil"
@@ -17,25 +20,23 @@ import (
 // @intent strict 모드에서 실제 실패로 간주할 lint 항목만 다시 집계한다.
 // @domainRule action: ignore로 선언된 규칙은 strict 실패 수에서 제외한다.
 func countNonIgnored(report *docs.LintReport) int {
-	rules := viper.Get("rules")
+	return countNonIgnoredWithRules(report, configuredLintRules())
+}
+
+func countNonIgnoredWithRules(report *docs.LintReport, rules []lintRule) int {
 	ignoreSet := map[string]bool{}
 	var ignoreRegexps []*regexp.Regexp
 
-	if ruleSlice, ok := rules.([]any); ok {
-		for _, r := range ruleSlice {
-			if rm, ok := r.(map[string]any); ok {
-				action, _ := rm["action"].(string)
-				pattern, _ := rm["pattern"].(string)
-				if action == "ignore" && pattern != "" {
-					if pathutil.IsRegexPattern(pattern) {
-						if re, err := regexp.Compile(pattern); err == nil {
-							ignoreRegexps = append(ignoreRegexps, re)
-						}
-					} else {
-						ignoreSet[pattern] = true
-					}
-				}
+	for _, rule := range rules {
+		if rule.Action != "ignore" || rule.Pattern == "" {
+			continue
+		}
+		if pathutil.IsRegexPattern(rule.Pattern) {
+			if re, err := regexp.Compile(rule.Pattern); err == nil {
+				ignoreRegexps = append(ignoreRegexps, re)
 			}
+		} else {
+			ignoreSet[rule.Pattern] = true
 		}
 	}
 
@@ -95,6 +96,204 @@ func countNonIgnored(report *docs.LintReport) int {
 	return total
 }
 
+func configuredLintRules() []lintRule {
+	var rules []lintRule
+	if err := viper.UnmarshalKey("rules", &rules); err == nil && len(rules) > 0 {
+		return rules
+	}
+	return flattenLintRules(viper.Get("rules"))
+}
+
+func flattenLintRules(raw any) []lintRule {
+	var out []lintRule
+	switch rules := raw.(type) {
+	case []any:
+		for _, item := range rules {
+			if rule, ok := parseLintRule(item); ok {
+				out = append(out, rule)
+			}
+		}
+	case []map[string]any:
+		for _, item := range rules {
+			if rule, ok := parseLintRule(item); ok {
+				out = append(out, rule)
+			}
+		}
+	default:
+		rv := reflect.ValueOf(raw)
+		if rv.IsValid() && rv.Kind() == reflect.Slice {
+			for i := 0; i < rv.Len(); i++ {
+				if rule, ok := parseLintRule(rv.Index(i).Interface()); ok {
+					out = append(out, rule)
+				}
+			}
+		}
+	}
+	return out
+}
+
+func parseLintRule(raw any) (lintRule, bool) {
+	switch item := raw.(type) {
+	case lintRule:
+		return item, true
+	case map[string]any:
+		return lintRuleFromMapLookup(func(key string) (any, bool) {
+			v, ok := item[key]
+			return v, ok
+		})
+	default:
+		rv := reflect.ValueOf(raw)
+		if rv.IsValid() && rv.Kind() == reflect.Map {
+			return lintRuleFromMapLookup(func(key string) (any, bool) {
+				for _, candidate := range rv.MapKeys() {
+					if fmt.Sprint(candidate.Interface()) == key {
+						return rv.MapIndex(candidate).Interface(), true
+					}
+				}
+				return nil, false
+			})
+		}
+		return lintRule{}, false
+	}
+}
+
+func lintRuleFromMapLookup(lookup func(string) (any, bool)) (lintRule, bool) {
+	rule := lintRule{}
+	if v, ok := lookup("pattern"); ok {
+		rule.Pattern, _ = v.(string)
+	}
+	if v, ok := lookup("category"); ok {
+		rule.Category, _ = v.(string)
+	}
+	if v, ok := lookup("action"); ok {
+		rule.Action, _ = v.(string)
+	}
+	if v, ok := lookup("auto"); ok {
+		rule.Auto, _ = v.(bool)
+	}
+	if v, ok := lookup("created"); ok {
+		rule.Created, _ = v.(string)
+	}
+	return rule, rule.Pattern != "" || rule.Category != "" || rule.Action != ""
+}
+
+type lintRuleDoc struct {
+	Rules []lintRule `yaml:"rules"`
+}
+
+type lintRule struct {
+	Pattern  string `yaml:"pattern"`
+	Category string `yaml:"category"`
+	Action   string `yaml:"action"`
+	Auto     bool   `yaml:"auto,omitempty"`
+	Created  string `yaml:"created,omitempty"`
+}
+
+func currentLintStateDir(historyDir string) string {
+	if historyDir != "" {
+		return historyDir
+	}
+	return ".ccg"
+}
+
+func mergeLintRulesWithAutoRules(stateDir string) ([]lintRule, error) {
+	autoRules, err := docs.LoadAutoRules(filepath.Join(stateDir, "auto-rules.yaml"))
+	if err != nil {
+		return nil, err
+	}
+	baseRules := configuredLintRules()
+	merged := make([]lintRule, 0, len(baseRules)+len(autoRules.Rules))
+	for _, rule := range baseRules {
+		merged = append(merged, rule)
+	}
+	for _, rule := range autoRules.Rules {
+		merged = append(merged, lintRule{
+			Pattern:  rule.Pattern,
+			Category: rule.Category,
+			Action:   rule.Action,
+			Auto:     rule.Auto,
+			Created:  rule.Created,
+		})
+	}
+	return merged, nil
+}
+
+func migrateAutoRulesFromConfig(cfgPath, stateDir string) (int, error) {
+	data, err := os.ReadFile(cfgPath)
+	if err != nil {
+		return 0, err
+	}
+
+	var root yaml.Node
+	if err := yaml.Unmarshal(data, &root); err != nil {
+		return 0, err
+	}
+
+	autoRules, err := docs.LoadAutoRules(filepath.Join(stateDir, "auto-rules.yaml"))
+	if err != nil {
+		return 0, err
+	}
+
+	triggered := make([]string, 0)
+	if len(root.Content) == 0 {
+		return 0, nil
+	}
+	doc := root.Content[0]
+	if doc.Kind != yaml.MappingNode {
+		return 0, nil
+	}
+
+	for i := 0; i+1 < len(doc.Content); i += 2 {
+		key := doc.Content[i]
+		value := doc.Content[i+1]
+		if key.Value != "rules" || value.Kind != yaml.SequenceNode {
+			continue
+		}
+
+		kept := make([]*yaml.Node, 0, len(value.Content))
+		for _, item := range value.Content {
+			rule, isAuto := decodeLintRuleNode(item)
+			if isAuto {
+				if rule.Category != "" && rule.Pattern != "" {
+					triggered = append(triggered, rule.Category+":"+rule.Pattern)
+				}
+				continue
+			}
+			kept = append(kept, item)
+		}
+		value.Content = kept
+		break
+	}
+
+	if len(triggered) == 0 {
+		return 0, nil
+	}
+
+	added := autoRules.Upsert(triggered)
+	if err := autoRules.Save(filepath.Join(stateDir, "auto-rules.yaml")); err != nil {
+		return 0, err
+	}
+	out, err := yaml.Marshal(&root)
+	if err != nil {
+		return 0, err
+	}
+	if err := os.WriteFile(cfgPath, out, 0o644); err != nil {
+		return 0, err
+	}
+	return len(added), nil
+}
+
+func decodeLintRuleNode(node *yaml.Node) (lintRule, bool) {
+	var rule lintRule
+	if node == nil || node.Kind != yaml.MappingNode {
+		return rule, false
+	}
+	if err := node.Decode(&rule); err != nil {
+		return lintRule{}, false
+	}
+	return rule, rule.Auto
+}
+
 // newLintCmd creates the docs lint command.
 // @intent 문서 품질 점검과 Twice Rule 자동 기록을 하나의 CLI 흐름으로 제공한다.
 // @domainRule 같은 이슈가 두 번 연속 발견되면 warn 규칙 후보로 승격한다.
@@ -106,6 +305,7 @@ func newLintCmd(deps *Deps) *cobra.Command {
 	var excludePatterns []string
 	var strict bool
 	var historyDir string
+	var migrateAutoRules bool
 
 	cmd := &cobra.Command{
 		Use:   "lint",
@@ -116,6 +316,30 @@ func newLintCmd(deps *Deps) *cobra.Command {
 				return errDBNotInitialized
 			}
 
+			stateDir := currentLintStateDir(historyDir)
+			lintRules := configuredLintRules()
+			if migrateAutoRules {
+				cfgPath := viper.ConfigFileUsed()
+				if cfgPath == "" {
+					cfgPath = ".ccg.yaml"
+				}
+				migrated, err := migrateAutoRulesFromConfig(cfgPath, stateDir)
+				if err != nil {
+					return trace.Wrap(err, "migrate auto rules")
+				}
+				if migrated == 0 {
+					fmt.Fprintln(stdout(cmd), "Nothing to migrate.")
+				} else {
+					fmt.Fprintf(stdout(cmd), "Migrated %d auto rules to .ccg/auto-rules.yaml\n", migrated)
+				}
+				return nil
+			}
+			if merged, err := mergeLintRulesWithAutoRules(stateDir); err != nil {
+				deps.Logger.Warn("load auto rules for lint failed", "error", err)
+			} else {
+				lintRules = merged
+			}
+
 			absOut, err := filepath.Abs(resolveOutDir(outDir))
 			if err != nil {
 				return trace.Wrap(err, "resolve out path")
@@ -211,10 +435,7 @@ func newLintCmd(deps *Deps) *cobra.Command {
 
 			// Twice Rule: compare with previous run history
 			{
-				hDir := historyDir
-				if hDir == "" {
-					hDir = ".ccg"
-				}
+				hDir := stateDir
 				histPath := filepath.Join(hDir, "lint-history.json")
 
 				history, err := docs.LoadHistory(histPath)
@@ -254,22 +475,30 @@ func newLintCmd(deps *Deps) *cobra.Command {
 					}
 
 					if len(triggered) > 0 {
-						fmt.Fprintf(out, "Twice Rule triggered (%d):\n", len(triggered))
-						for _, key := range triggered {
-							fmt.Fprintf(out, "  %s → added to .ccg.yaml rules (warn)\n", key)
-						}
-						fmt.Fprintln(out)
-
-						cfgPath := ".ccg.yaml"
-						if writeErr := docs.WriteYamlRules(cfgPath, triggered); writeErr != nil {
-							deps.Logger.Warn("write yaml rules failed", "error", writeErr)
+						autoRulesPath := filepath.Join(hDir, "auto-rules.yaml")
+						autoRules, loadErr := docs.LoadAutoRules(autoRulesPath)
+						if loadErr != nil {
+							deps.Logger.Warn("load auto rules failed", "error", loadErr)
+						} else {
+							added := autoRules.Upsert(triggered)
+							if saveErr := autoRules.Save(autoRulesPath); saveErr != nil {
+								deps.Logger.Warn("save auto rules failed", "error", saveErr)
+							}
+							fmt.Fprintf(out, "Twice Rule triggered (%d):\n", len(triggered))
+							for _, key := range triggered {
+								fmt.Fprintf(out, "  %s → recorded in .ccg/auto-rules.yaml (warn)\n", key)
+							}
+							fmt.Fprintln(out)
+							if len(added) == 0 {
+								deps.Logger.Debug("no new auto rules added", "path", autoRulesPath)
+							}
 						}
 					}
 				}
 			}
 
 			if strict {
-				strictTotal := countNonIgnored(report)
+				strictTotal := countNonIgnoredWithRules(report, lintRules)
 				if strictTotal > 0 {
 					return trace.New(fmt.Sprintf("lint found %d issues", strictTotal))
 				}
@@ -283,5 +512,7 @@ func newLintCmd(deps *Deps) *cobra.Command {
 	cmd.Flags().StringArrayVar(&excludePatterns, "exclude", nil, "Exclude files/paths matching pattern (repeatable)")
 	cmd.Flags().BoolVar(&strict, "strict", false, "Exit with error if any issues are found (useful for CI/pre-commit)")
 	cmd.Flags().StringVar(&historyDir, "history-dir", "", "Directory for lint history (default: .ccg)")
+	cmd.Flags().BoolVar(&migrateAutoRules, "migrate-auto-rules", false, "Move legacy auto: true lint rules from .ccg.yaml into .ccg/auto-rules.yaml")
+	_ = cmd.Flags().MarkHidden("migrate-auto-rules")
 	return cmd
 }