importflow

type CSVOptions struct {
	Table      string // logical table name; default "csv"
	Delimiter  rune   // default ','
	SampleSize int    // sample rows in Schemas(); default 5
}

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

type Column struct {
	Name string
	Type string // "integer","number","text","timestamp","" (unknown)
}

type Dialect string

type DumpOptions struct {
	Dialect    Dialect // default DialectAuto
	SampleSize int     // sample rows per table in Schemas(); default 5
}

type EntityMap struct {
	Ref       string   `json:"ref"`     // local handle, e.g. "customer"
	Type      string   `json:"type"`    // entity class
	IDTmpl    string   `json:"id_tmpl"` // "{customer_id}"
	LabelTmpl string   `json:"label_tmpl,omitempty"`
	Props     []string `json:"props,omitempty"`
}

type Goal struct {
	BuildRAG bool
	BuildKG  bool
	Hint     string // domain hint passed to the AI inferer
}

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

type KGPlan struct {
	Entities    []EntityMap   `json:"entities,omitempty"`
	Relations   []RelationMap `json:"relations,omitempty"`
	TextExtract []TextExtract `json:"text_extract,omitempty"`
}

type LLMInferer struct {
	Client graphflow.JSONGenerator
}

type LLMRefiner struct {
	Client graphflow.JSONGenerator
}

type MCPServerOptions struct {
	Implementation *mcp.Implementation
	Instructions   string
	Logger         *slog.Logger
}

type MappingInferer interface {
	InferPlan(ctx context.Context, schemas []Schema, goal Goal) (MappingPlan, error)
}

type MappingPlan struct {
	Tables map[string]TablePlan `json:"tables"`
}

type Option func(*Importer)

type RAGPlan struct {
	Namespace   string   `json:"namespace,omitempty"`
	ContentTmpl string   `json:"content_tmpl"`        // "{title}\n\n{body}"
	IDColumn    string   `json:"id_column,omitempty"` // default synthesized "table:row"
	Metadata    []string `json:"metadata,omitempty"`  // columns copied into metadata
	Refine      bool     `json:"refine,omitempty"`    // run TextRefiner before embedding
}

type Record struct {
	Table  string
	Values map[string]string // column name -> string value
	Nulls  map[string]bool   // column name -> is NULL
	Row    int               // 0-based row index within the table
}

type RelationMap struct {
	Subject   string `json:"subject"`
	Predicate string `json:"predicate"`
	Object    string `json:"object"`
}

type Report struct {
	RowsRead           int
	ChunksIndexed      int
	TriplesCreated     int
	Skipped            int
	UnparsedStatements []string
	Errors             []error
}

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

type Schema struct {
	Table   string
	Columns []Column
	Sample  []Record
}

type Source interface {
	// Schemas returns table schemas with up to a few sample rows each.
	Schemas(ctx context.Context) ([]Schema, error)
	// Records streams every record; fn returning an error aborts iteration.
	Records(ctx context.Context, fn func(Record) error) error
	// Close releases any underlying resources.
	Close() error
}

type TablePlan struct {
	Skip bool     `json:"skip,omitempty"`
	RAG  *RAGPlan `json:"rag,omitempty"`
	KG   *KGPlan  `json:"kg,omitempty"`
}

type TextExtract struct {
	Column string   `json:"column"`
	Types  []string `json:"types,omitempty"`
}

type TextRefiner interface {
	Refine(ctx context.Context, table, column, raw string) (string, error)
}

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