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 {

		if policyPath == "" || dataPath == "" || targets == "" {
			return fmt.Errorf("policy, data, and target are required")
		}

		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(context.Background(), 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(facts); err != nil {
			return fmt.Errorf("failed to load facts: %w", err)
		}

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

		targetList := strings.Split(targets, ",")
		ctx := context.Background()

		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 {

					if format == "json" {

					}

					s := row["S"]
					o := row["O"]

					line := fmt.Sprintf("<%s> <%s> \"%v\" .\n", s, target, o)
					f.WriteString(line)
				}
				continue
			}

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

					line := fmt.Sprintf("<%s> <%s> \"true\" .\n", s, target)
					f.WriteString(line)
				}
				continue
			}
		}

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