genkit

type AdapterRegistry struct {
	// contains filtered or unexported fields
}

type AgentAdapter interface {
	// Name returns the agent identifier (e.g., "kiro", "codebuddy", "cursor").
	// This name is used in CLI commands like `devgen rules --agent kiro`.
	Name() string

	// OutputDir returns the directory path where rules should be written.
	// The path is relative to the project root.
	// Examples:
	//   - Kiro: ".kiro/steering"
	//   - CodeBuddy: ".codebuddy/rules"
	//   - Cursor: ".cursor/rules"
	OutputDir() string

	// Transform converts a generic Rule into agent-specific format.
	// It returns:
	//   - filename: the output filename (e.g., "enumgen.md")
	//   - content: the complete file content with frontmatter and markdown
	//   - error: any transformation error
	//
	// The transformation typically involves:
	//   1. Converting Rule fields to agent-specific frontmatter
	//   2. Formatting the frontmatter as YAML
	//   3. Combining frontmatter with the rule content
	Transform(rule Rule) (filename string, content string, err error)
}

type Annotation struct {
	Tool  string            // tool name (e.g., "enumgen")
	Name  string            // annotation name (e.g., "enum")
	Args  map[string]string // key=value args
	Flags []string          // positional args without =
	Raw   string
}

type AnnotationConfig struct {
	// Name is the annotation name (e.g., "enum", "validate").
	Name string `toml:"name"`

	// Type is where the annotation can be applied: "type" or "field".
	Type string `toml:"type"`

	// Doc is the documentation for this annotation.
	Doc string `toml:"doc"`

	// Params defines parameter configuration.
	Params *AnnotationParams `toml:"params"`

	// LSP defines LSP integration configuration.
	LSP *LSPConfig `toml:"lsp"`
}

type AnnotationParams struct {
	// Type is the parameter type: "string", "number", "bool", "list", or "enum".
	// Can also be an array of types for multiple accepted types.
	Type any `toml:"type"`

	// Values is the list of allowed values for enum type.
	Values []string `toml:"values"`

	// Placeholder is the placeholder text for the parameter.
	Placeholder string `toml:"placeholder"`

	// MaxArgs is the maximum number of arguments allowed.
	MaxArgs int `toml:"maxArgs"`

	// Docs provides documentation for each enum value.
	Docs map[string]string `toml:"docs"`
}

type Annotations []*Annotation

type CodeBuddyAdapter struct{}

type Config struct {
	// Plugins defines external tool plugins to load.
	Plugins []PluginConfig `toml:"plugins"`

	// Tools contains tool-specific configurations (annotations, output suffix, etc.)
	Tools map[string]ToolConfig `toml:"tools"`

	// Rules contains AI rules configuration.
	Rules RulesConfig `toml:"rules"`
}

type ConfigurableTool interface {
	Tool

	// Config returns the tool's configuration including annotations metadata.
	// This is used by VSCode extension for syntax highlighting and auto-completion,
	// and by CLI for validation.
	Config() ToolConfig
}

type CursorAdapter struct{}

type Diagnostic struct {
	Severity DiagnosticSeverity `json:"severity"`
	Message  string             `json:"message"`
	File     string             `json:"file"`
	Line     int                `json:"line"`
	Column   int                `json:"column"`
	EndLine  int                `json:"endLine,omitempty"`
	EndCol   int                `json:"endColumn,omitempty"`
	Tool     string             `json:"tool"`
	Code     string             `json:"code,omitempty"` // e.g., "E001"
}

type DiagnosticCollector struct {
	// contains filtered or unexported fields
}

type DiagnosticSeverity string

type DryRunResult struct {
	Success     bool              `json:"success"`
	Files       map[string]string `json:"files,omitempty"` // filename -> content preview
	Diagnostics []Diagnostic      `json:"diagnostics,omitempty"`
	Stats       DryRunStats       `json:"stats"`
}

type DryRunStats struct {
	PackagesLoaded int `json:"packagesLoaded"`
	FilesGenerated int `json:"filesGenerated"`
	ErrorCount     int `json:"errorCount"`
	WarningCount   int `json:"warningCount"`
}

type Enum struct {
	Name           string
	Doc            string
	Pkg            *Package
	Values         []*EnumValue
	UnderlyingType string // e.g., "int", "string", "int64"
}

type EnumValue struct {
	Name    string
	Value   string
	Doc     string
	Comment string
	Pos     token.Position // source position
}

type Field struct {
	Name           string
	Type           string // declared type (e.g., "Email", "*User", "[]string")
	UnderlyingType string // underlying type (e.g., "string", "*struct", "[]string")
	Tag            string
	Doc            string
	Comment        string
	Pos            token.Position // source position
}

type GeneratedFile struct {
	// contains filtered or unexported fields
}

type Generator struct {
	// Packages are the loaded packages.
	Packages []*Package

	// Fset is the token file set.
	Fset *token.FileSet
	// contains filtered or unexported fields
}

type GoDoc string

type GoFunc struct {
	Doc     GoDoc
	Name    string
	Params  GoParams
	Results GoResults
}

type GoIdent struct {
	GoImportPath GoImportPath
	GoName       string
}

type GoImportPath string

type GoMethod struct {
	Doc     GoDoc      // documentation comment (without //)
	Recv    GoReceiver // receiver
	Name    string     // method name
	Params  GoParams   // parameters
	Results GoResults  // return values
}

type GoPackageName string

type GoParam struct {
	Name string // parameter name (can be empty for returns)
	Type any    // type: string, GoIdent
}

type GoParams struct {
	List     []GoParam
	Variadic bool
}

type GoPrintable interface {
	PrintTo(g *GeneratedFile)
}

type GoReceiver struct {
	Name    string // receiver name (e.g., "x")
	Type    any    // receiver type: string, GoIdent
	Pointer bool   // whether receiver is pointer
}

type GoResults []GoParam

type KiroAdapter struct{}

type LSPConfig struct {
	// Enabled indicates whether LSP integration is enabled.
	Enabled bool `toml:"enabled"`

	// Provider is the LSP provider (e.g., "gopls").
	Provider string `toml:"provider"`

	// Feature is the LSP feature type: "method", "type", "symbol".
	Feature string `toml:"feature"`

	// Signature is the required method signature (e.g., "func() error").
	Signature string `toml:"signature"`

	// ResolveFrom specifies where to find the type: "fieldType", "receiverType".
	ResolveFrom string `toml:"resolveFrom"`
}

type Logger struct {
	// contains filtered or unexported fields
}

type Options struct {
	// Tags are build tags to use when loading packages.
	Tags []string

	// Dir is the working directory. If empty, uses current directory.
	Dir string

	// IgnoreGeneratedFiles when true, ignores files that start with
	// "// Code generated" comment. This is useful for ignoring generated
	// files that may have syntax errors.
	IgnoreGeneratedFiles bool

	// IncludeTests when true, tools should also generate *_test.go files.
	// Tools can check this option via Generator.IncludeTests() method.
	IncludeTests bool
}

type Package struct {
	Name      string
	PkgPath   string
	Dir       string
	GoFiles   []string
	Fset      *token.FileSet
	TypesPkg  *types.Package
	TypesInfo *types.Info
	Syntax    []*ast.File
	Types     []*Type
	Enums     []*Enum
}

type PluginConfig struct {
	// Name is the plugin/tool name (e.g., "customgen").
	Name string `toml:"name"`

	// Path is the path to the plugin.
	// For "source" type: Go package directory path
	// For "plugin" type: path to .so file
	Path string `toml:"path"`

	// Type specifies how to load the plugin.
	// - "source": compile Go source code at runtime (default)
	// - "plugin": load as Go plugin (.so)
	Type PluginType `toml:"type"`
}

type PluginLoader struct {
	// contains filtered or unexported fields
}

type PluginType string

type RawString string

type Rule struct {
	// Name is the rule file name (without extension).
	// Example: "enumgen", "validategen-basics"
	Name string

	// Description is a short description of what this rule covers.
	// Used by AI agents to decide whether to include this rule.
	// Example: "Go enum code generation with enumgen"
	Description string

	// Globs specifies file patterns that trigger this rule.
	// When files matching these patterns are referenced, the rule is auto-attached.
	// Example: []string{"*.go", "**/*_enum.go"}
	// Empty means the rule won't be auto-attached by file patterns.
	Globs []string

	// AlwaysApply indicates whether this rule should always be included.
	// If true, the rule is always in context (like Cursor's "Always" type).
	// If false, the rule is included based on Globs or manual reference.
	AlwaysApply bool

	// Content is the actual rule content in Markdown format.
	// This should be detailed, step-by-step documentation with examples.
	// Write it as if the reader knows nothing - be explicit and thorough.
	Content string
}

type RuleFrontmatter struct {
	Description string   `yaml:"description"`
	Globs       []string `yaml:"globs"`
	AlwaysApply bool     `yaml:"alwaysApply"`
}

type RuleTool interface {
	Tool

	// Rules returns the AI rules for this tool.
	// Each rule should be detailed, step-by-step documentation
	// with plenty of examples to help AI assistants understand
	// how to use this tool correctly.
	Rules() []Rule
}

type RulesConfig struct {
	// SourceDir is the directory containing project-level rule files.
	// If not set, project rules will not be loaded.
	SourceDir string `toml:"source_dir"`

	// IncludeBuiltin indicates whether to include devgen's built-in rules.
	// Default: true
	IncludeBuiltin *bool `toml:"include_builtin"`
}

type Tool interface {
	// Name returns the tool name (e.g., "enumgen", "validategen").
	Name() string

	// Run processes all packages and generates code.
	// It should handle logging internally.
	Run(gen *Generator, log *Logger) error
}

type ToolConfig struct {
	// OutputSuffix is the suffix for generated files (e.g., "_enum.go").
	OutputSuffix string `toml:"output_suffix"`

	// Annotations defines the annotations supported by this tool.
	Annotations []AnnotationConfig `toml:"annotations"`
}

type Type struct {
	Name     string
	Doc      string
	Pkg      *Package
	Fields   []*Field
	TypeSpec *ast.TypeSpec
}

type ValidatableTool interface {
	Tool

	// Validate checks for errors without generating files.
	// Returns diagnostics (errors/warnings) found during validation.
	// This is called in dry-run mode to provide IDE integration.
	Validate(gen *Generator, log *Logger) []Diagnostic
}