run

var RunCmd = &cobra.Command{
	Use:   "run",
	Short: "Perform batch inference (Logic ETL)",
	Long:  `Perform batch inference by loading raw data, applying Datalog rules, and exporting derived facts.`,
	RunE: func(cmd *cobra.Command, args []string) error {
		switch format {
		case formatNQuads, formatJSON:
		default:
			return exitcode.UsageErrorf("invalid --format %q: must be %q or %q", format, formatNQuads, formatJSON)
		}

		eng, err := engine.New()
		if err != nil {
			return fmt.Errorf("failed to initialize engine: %w", err)
		}

		policyBytes, err := os.ReadFile(policyPath)
		if err != nil {
			return fmt.Errorf("failed to read policy file: %w", err)
		}
		if err := eng.LoadPolicy(cmd.Context(), string(policyBytes)); err != nil {
			return fmt.Errorf("failed to load policy: %w", err)
		}

		// 3. Load Data
		var facts []string
		ext := strings.ToLower(filepath.Ext(dataPath))
		if ext == ".json" {
			dataBytes, err := os.ReadFile(dataPath)
			if err != nil {
				return fmt.Errorf("failed to read data file: %w", err)
			}
			var input any
			if err := json.Unmarshal(dataBytes, &input); err != nil {
				return fmt.Errorf("failed to unmarshal JSON: %w", err)
			}

			facts, err = engine.Flatten("root", input)
			if err != nil {
				return fmt.Errorf("failed to flatten JSON data: %w", err)
			}
		} else if ext == ".nq" || ext == ".nt" || ext == ".ttl" {

			triples, err := knowledge.ParseGraphFile(dataPath)
			if err != nil {
				return fmt.Errorf("failed to parse graph file: %w", err)
			}

			facts = knowledge.TriplesToFacts(triples)
		} else {
			return fmt.Errorf("unsupported data file extension: %s", ext)
		}

		if err := eng.LoadFacts(cmd.Context(), facts); err != nil {
			return fmt.Errorf("failed to load facts: %w", err)
		}

		targetList := strings.Split(targets, ",")
		ctx := cmd.Context()

		var derived []derivedFact
		for _, target := range targetList {
			target = strings.TrimSpace(target)

			query := fmt.Sprintf("%s(S, O)", target)
			results, err := eng.Query(ctx, nil, query)

			if err == nil && len(results) > 0 {
				for _, row := range results {
					derived = append(derived, derivedFact{
						Subject:   row["S"],
						Predicate: target,
						Object:    row["O"],
					})
				}
				continue
			}

			query = fmt.Sprintf("%s(S)", target)
			results, err = eng.Query(ctx, nil, query)
			if err == nil && len(results) > 0 {
				for _, row := range results {

					derived = append(derived, derivedFact{
						Subject:   row["S"],
						Predicate: target,
						Object:    "true",
					})
				}
				continue
			}
		}

		f, err := os.Create(outputPath)
		if err != nil {
			return fmt.Errorf("failed to create output file: %w", err)
		}
		defer f.Close()

		switch format {
		case formatJSON:
			if derived == nil {
				derived = []derivedFact{}
			}
			out, err := json.MarshalIndent(derived, "", "  ")
			if err != nil {
				return fmt.Errorf("failed to marshal JSON output: %w", err)
			}
			if _, err := f.Write(append(out, '\n')); err != nil {
				return fmt.Errorf("failed to write output: %w", err)
			}
		default:
			for _, d := range derived {

				if _, err := fmt.Fprintf(f, "<%s> <%s> %q .\n", d.Subject, d.Predicate, d.Object); err != nil {
					return fmt.Errorf("failed to write output: %w", err)
				}
			}
		}

		fmt.Printf("Inference complete. Results written to %s\n", outputPath)
		return nil
	},
}