docs

type APIGenerator ¶

type APIGenerator struct{}

APIGenerator produces API reference documentation from proto service definitions.

func (g *APIGenerator) Generate(ctx *Context) ([]GeneratedDoc, error)

func (g *APIGenerator) Name() string

type ArchitectureGenerator ¶

type ArchitectureGenerator struct{}

ArchitectureGenerator produces architecture overview documentation with Mermaid diagrams.

func (g *ArchitectureGenerator) Generate(ctx *Context) ([]GeneratedDoc, error)

func (g *ArchitectureGenerator) Name() string

type ConfigGenerator ¶

type ConfigGenerator struct{}

ConfigGenerator produces configuration reference documentation from config proto annotations.

func (g *ConfigGenerator) Generate(ctx *Context) ([]GeneratedDoc, error)

func (g *ConfigGenerator) Name() string

type Context ¶

type Context struct {
	ProjectConfig  *config.ProjectConfig
	Services       []codegen.ServiceDef
	ConfigMessages []codegen.ConfigMessage
	Contracts      []*ContractInfo
	Format         string // "markdown" or "hugo"
	ProjectDir     string
	ModulePath     string
}

Context holds all pre-parsed project data that generators use.

type ContractGenerator ¶

type ContractGenerator struct{}

ContractGenerator produces documentation for internal package contracts.

func (g *ContractGenerator) Generate(ctx *Context) ([]GeneratedDoc, error)

func (g *ContractGenerator) Name() string

type ContractInfo ¶

type ContractInfo struct {
	PackageName string
	Contract    *contract.ContractFile
}

ContractInfo holds a parsed contract with its package path.

type Deps ¶

type Deps struct {
	CodegenParser codegen.Parser   // descriptor + go.mod parsing
	Contract      contract.Service // contract.go AST parsing
}

Deps wires the cross-package collaborators docs needs. Each defaults to the canonical implementation when nil.

type GeneratedDoc ¶

type GeneratedDoc struct {
	Path    string // relative path within output dir (e.g. "api/index.md")
	Content []byte
}

GeneratedDoc represents a single generated documentation file.

type Generator ¶

type Generator interface {
	// Name returns the generator's identifier (e.g. "api", "architecture").
	Name() string

	// Generate produces documentation from the given context.
	Generate(ctx *Context) ([]GeneratedDoc, error)
}

Generator produces documentation files from project metadata.

type MockService ¶

type MockService struct {
	contractkit.Recorder
	RunFunc func(string, *config.ProjectConfig, *Overrides) error
}

MockService is a test mock for the Service interface.

The embedded contractkit.Recorder records every call so tests can assert call counts and captured arguments. Set XxxFunc fields to override per-method behaviour; unset methods return the canonical "MockService.<Method>Func not set" error.

func (m *MockService) Run(projectDir string, cfg *config.ProjectConfig, overrides *Overrides) error

type Overrides ¶

type Overrides struct {
	OutputDir  string
	Format     string
	Generators []string
}

Overrides allows CLI flags to override config values.

func (o *Overrides) Apply(cfg *config.DocsConfig)

type Registry ¶

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

Registry holds named generators that can be selectively enabled.

func DefaultRegistry() *Registry

func NewRegistry() *Registry

func (r *Registry) Get(name string) Generator

func (r *Registry) Names() []string

func (r *Registry) Register(g Generator)

type Service ¶

type Service interface {
	Run(projectDir string, cfg *config.ProjectConfig, overrides *Overrides) error
}

Service is the docs package's public seam: one entry point that runs the configured generators against a project directory.

func New(d Deps) Service