all tests pass

package.json

@@ -3,7 +3,8 @@
   "version": "1.0.0",
   "type": "module",
   "scripts": {
-    "test": "vitest --run"
+    "test": "vitest --run",
+    "pipeline": "node ./src/pipeline/pipeline_cli.js"
   },
   "devDependencies": {
     "vitest": "^1.6.0"

src/generator/generator_core.mjs

@@ -1,4 +1,4 @@
-// generat../generator/generator_core.mjs
+// src/generator/generator_core.mjs
 import fs from 'fs/promises';
 import path from 'path';
 

src/pipeline/pipeline.mjs

@@ -0,0 +1,178 @@
+// src/pipeline/pipeline.mjs
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { loadProvider } from '../providers/provider.mjs';
+import { hybridSearch } from '../retrieval/retrieval.mjs';
+import { runGenerator } from '../generator/generator_core.mjs';
+import { runVerifier } from '../verifier/verifier_core.mjs';
+import { runReward } from '../reward/reward_core.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PROJECT_ROOT = path.join(__dirname, '..', '..');
+
+const DEFAULT_SEEDS_PATH = path.join(
+  PROJECT_ROOT,
+  'test_samples',
+  'seed_questions.jsonl',
+);
+
+const DEFAULT_OUT_PATH = path.join(
+  PROJECT_ROOT,
+  'gold',
+  'pipeline_gold.jsonl',
+);
+
+/**
+ * Load JSONL seed questions.
+ * Each line may be:
+ *  - { "question": "..." }
+ *  - { "prompt": "..." }
+ *  - { "text": "..." }
+ *  - or just a raw string
+ */
+export async function loadSeedQuestions(seedsPath = DEFAULT_SEEDS_PATH) {
+  const txt = await fs.readFile(seedsPath, 'utf8');
+  return txt
+    .split('\n')
+    .map((l) => l.trim())
+    .filter(Boolean)
+    .map((line) => JSON.parse(line));
+}
+
+/**
+ * Extract a question string from a seed record.
+ */
+export function seedToQuestion(seed) {
+  if (typeof seed === 'string') return seed;
+  return seed.question || seed.prompt || seed.text || '';
+}
+
+/**
+ * Run a single pipeline step for one question.
+ *
+ * Orchestrates:
+ *   retrieval → generator → verifier → reward
+ *
+ * Returns a structured result:
+ *   {
+ *     status: 'accepted' | 'generator_failed' | 'verifier_rejected' | 'reward_rejected',
+ *     question,
+ *     context,
+ *     gen,
+ *     ver,
+ *     rew,
+ *   }
+ */
+export async function runPipelineStep({
+  question,
+  provider,
+  retrievalMode = process.env.RETRIEVAL_MODE || 'hybrid',
+  k = Number(process.env.RETRIEVAL_K || '6'),
+}) {
+  if (!question || !question.trim()) {
+    return { status: 'invalid_question', question };
+  }
+
+  const prov = provider || loadProvider();
+
+  // --- Retrieval ---
+  let context = [];
+  if (retrievalMode === 'hybrid' || !retrievalMode) {
+    context = await hybridSearch(question, k);
+  } else {
+    // for now, other modes can be added later
+    context = await hybridSearch(question, k);
+  }
+
+  // --- Generator ---
+  const gen = await runGenerator(question, context, prov);
+  if (!gen || gen.ok === false) {
+    return { status: 'generator_failed', question, context, gen };
+  }
+
+  // --- Verifier ---
+  const ver = await runVerifier(gen, prov);
+  if (!ver || ver.ok === false) {
+    return { status: 'verifier_rejected', question, context, gen, ver };
+  }
+
+  // --- Reward ---
+  const rew = await runReward(gen, prov);
+  if (!rew || rew.ok === false) {
+    return { status: 'reward_rejected', question, context, gen, ver, rew };
+  }
+
+  return {
+    status: 'accepted',
+    question,
+    context,
+    gen,
+    ver,
+    rew,
+  };
+}
+
+/**
+ * Append a single accepted record to a JSONL file.
+ */
+export async function appendGoldRecord(outPath, record) {
+  const line = JSON.stringify(record) + '\n';
+  await fs.mkdir(path.dirname(outPath), { recursive: true });
+  await fs.appendFile(outPath, line, 'utf8');
+}
+
+/**
+ * Run the pipeline over a batch of seed questions and write accepted
+ * samples to a JSONL file.
+ *
+ * Options:
+ *   - seedsPath: JSONL of seeds (defaults to test_samples/seed_questions.jsonl)
+ *   - outPath:   output JSONL (defaults to gold/pipeline_gold.jsonl)
+ *   - limit:     max number of seeds to process
+ *
+ * Returns:
+ *   { total, processed, accepted, outPath }
+ */
+export async function runPipelineBatch({
+  seedsPath = DEFAULT_SEEDS_PATH,
+  outPath = DEFAULT_OUT_PATH,
+  limit,
+} = {}) {
+  const provider = loadProvider();
+  const seeds = await loadSeedQuestions(seedsPath);
+  const max = typeof limit === 'number' ? limit : seeds.length;
+
+  let processed = 0;
+  let accepted = 0;
+
+  for (const seed of seeds.slice(0, max)) {
+    const question = seedToQuestion(seed);
+    const result = await runPipelineStep({ question, provider });
+
+    processed += 1;
+
+    if (result.status === 'accepted') {
+      const record = {
+        question,
+        context: result.context,
+        sample: result.gen, // treat generator result as opaque sample
+        verifier: result.ver,
+        reward: result.rew,
+      };
+
+      await appendGoldRecord(outPath, record);
+      accepted += 1;
+    }
+  }
+
+  return {
+    total: seeds.length,
+    processed,
+    accepted,
+    outPath,
+  };
+}

src/pipeline/pipeline_cli.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+// src/pipeline/pipeline_cli.js
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import fs from 'fs/promises';
+
+import { loadProvider } from '../providers/provider.mjs';
+import {
+  loadSeedQuestions,
+  seedToQuestion,
+  runPipelineStep,
+  appendGoldRecord,
+  runPipelineBatch
+} from './pipeline.mjs';
+
+//
+// ---- CLI Helpers ----
+//
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const out = {};
+
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+
+    if (a === '--seeds' || a === '-s') {
+      out.seeds = args[++i];
+    } else if (a === '--out' || a === '-o') {
+      out.out = args[++i];
+    } else if (a === '--limit' || a === '-l') {
+      out.limit = Number(args[++i]);
+    } else if (a === '--provider' || a === '-p') {
+      out.provider = args[++i];
+    } else if (a === '--help' || a === '-h') {
+      out.help = true;
+    }
+  }
+
+  return out;
+}
+
+function showHelp() {
+  console.log(`
+distill-pipeline — Full Distillation Cycle Runner
+
+Usage:
+  node pipeline_cli.js [options]
+
+Options:
+  --seeds <file>     Path to seed JSONL file (default: test_samples/seed_questions.jsonl)
+  --out <file>       Path to output JSONL      (default: gold/pipeline_gold.jsonl)
+  --limit <n>        Max number of seeds to process
+  --provider <name>  Provider override: ollama | openai | http
+  -h, --help         Show this help
+
+Examples:
+  node pipeline_cli.js --limit 25
+  node pipeline_cli.js -s custom_seeds.jsonl -o gold/round1.jsonl
+`);
+}
+
+//
+// ---- MAIN ----
+//
+async function main() {
+  const args = parseArgs();
+
+  if (args.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  // ---- Resolve paths ----
+  const seedsPath = args.seeds
+    ? path.resolve(args.seeds)
+    : path.resolve(__dirname, '../../test_samples/seed_questions.jsonl');
+
+  const outPath = args.out
+    ? path.resolve(args.out)
+    : path.resolve(__dirname, '../../gold/pipeline_gold.jsonl');
+
+  const limit = args.limit ?? undefined;
+
+  // ---- Provider override ----
+  if (args.provider) {
+    process.env.PROVIDER_TYPE = args.provider;
+  }
+
+  // ---- Announce run ----
+  console.log(`\n🚀 Starting Distillation Pipeline`);
+  console.log(`   Seeds:    ${seedsPath}`);
+  console.log(`   Output:   ${outPath}`);
+  console.log(`   Provider: ${process.env.PROVIDER_TYPE || 'ollama (default)'}`);
+  console.log(`   Limit:    ${limit ?? 'none'}\n`);
+
+  // ---- Run batch ----
+  const result = await runPipelineBatch({
+    seedsPath,
+    outPath,
+    limit,
+  });
+
+  console.log(`\n🎉 Pipeline completed`);
+  console.log(`   Total Seeds:    ${result.total}`);
+  console.log(`   Processed:      ${result.processed}`);
+  console.log(`   Accepted:       ${result.accepted}`);
+  console.log(`   Written to:     ${result.outPath}\n`);
+}
+
+main().catch((err) => {
+  console.error(`❌ Pipeline error:`, err);
+  process.exit(1);
+});

src/providers/http_provider.mjs

@@ -1,33 +1,26 @@
+// src/providers/http_provider.mjs
 import { BaseProvider } from './base.mjs';
 
 export class HttpProvider extends BaseProvider {
   constructor() {
     super();
-    this.url = process.env.HTTP_PROVIDER_URL || "http://localhost:8000/generate";
-    this.model = process.env.GENERATOR_MODEL || "qwen2.5-7b-instruct";
+    this.url = process.env.HTTP_PROVIDER_URL;
   }
 
-  async generate(prompt, opts = {}) {
-    const body = {
-      model: this.model,
-      prompt,
-      ...opts
-    };
-
+  async generate(prompt) {
     const resp = await fetch(this.url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ prompt })
     });
 
+    if (!resp.ok) {
+      throw new Error(`HttpProvider error: ${resp.status}`);
+    }
+
     const data = await resp.json();
 
-    return (
-      data.output ||
-      data.response ||
-      data.text ||
-      data.result ||
-      ""
-    );
+    // Expect: { output: "<json string>" }
+    return data.output || data.response || '';
   }
 }

src/providers/ollama_provider.mjs

@@ -1,31 +1,31 @@
+// src/providers/ollama_provider.mjs
 import { BaseProvider } from './base.mjs';
 
 export class OllamaProvider extends BaseProvider {
   constructor() {
     super();
-    this.url = process.env.OLLAMA_URL || "http://localhost:11434/api/generate";
-    this.model = process.env.GENERATOR_MODEL || "qwen2.5-7b-instruct";
+    this.url = process.env.OLLAMA_URL || 'http://localhost:11434/api/generate';
+    this.model = process.env.GENERATOR_MODEL || 'qwen3-vl:8b-thinking';
   }
 
-  async generate(prompt, opts = {}) {
-    const body = {
-      model: this.model,
-      prompt,
-      stream: false,
-      ...opts
-    };
-
+  async generate(prompt) {
     const resp = await fetch(this.url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: this.model,
+        prompt,
+        stream: false
+      })
     });
 
     if (!resp.ok) {
-      throw new Error(`Ollama error ${resp.status}`);
+      throw new Error(`OllamaProvider error: ${resp.status}`);
     }
 
     const data = await resp.json();
-    return data.response || data.output || data;
+
+    // Must return *raw string*, because generator/verifier/reward expect text they parse with JSON.parse()
+    return data.response;
   }
 }

src/providers/openai_provider.mjs

@@ -1,30 +1,31 @@
+// src/providers/openai_provider.mjs
 import { BaseProvider } from './base.mjs';
 
 export class OpenAIProvider extends BaseProvider {
   constructor() {
     super();
-    this.key = process.env.OPENAI_API_KEY;
-    this.model = process.env.GENERATOR_MODEL || "gpt-4o-mini";
-    this.url = "https://api.openai.com/v1/chat/completions";
+    this.apiKey = process.env.OPENAI_API_KEY;
+    this.model = process.env.GENERATOR_MODEL || 'gpt-4o-mini';
   }
 
-  async generate(prompt, opts = {}) {
-    const body = {
-      model: this.model,
-      messages: [{ role: "user", content: prompt }],
-      temperature: opts.temperature ?? 0.7
-    };
-
-    const resp = await fetch(this.url, {
-      method: "POST",
+  async generate(prompt) {
+    const resp = await fetch('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
       headers: {
-        "Authorization": `Bearer ${this.key}`,
-        "Content-Type": "application/json"
+        'Authorization': `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json'
       },
-      body: JSON.stringify(body)
+      body: JSON.stringify({
+        model: this.model,
+        messages: [{ role: 'user', content: prompt }]
+      })
     });
 
+    if (!resp.ok) {
+      throw new Error(`OpenAIProvider error: ${resp.status}`);
+    }
+
     const data = await resp.json();
-    return data.choices?.[0]?.message?.content ?? "";
+    return data.choices[0].message.content;
   }
 }

src/providers/provider.mjs

@@ -3,6 +3,14 @@ import { OllamaProvider } from './ollama_provider.mjs';
 import { OpenAIProvider } from './openai_provider.mjs';
 import { HttpProvider } from './http_provider.mjs';
 
+// Add this at bottom of provider.mjs temporarily:
+export async function debugLoad() {
+  const p = loadProvider();
+  console.log('Loaded provider:', p);
+  console.log('typeof generate:', typeof p.generate);
+}
+
+
 export function loadProvider() {
   const type = (process.env.PROVIDER_TYPE || "ollama").toLowerCase();
 

src/reward/reward_core.mjs

@@ -1,4 +1,4 @@
-// rewa../reward/reward_core.mjs
+// src/reward/reward_core.mjs
 import fs from 'fs/promises';
 import path from 'path';
 

src/verifier/verifier_core.mjs

@@ -1,4 +1,4 @@
-// verifi../verifier/verifier_core.mjs
+// src/verifier/verifier_core.mjs
 import fs from 'fs/promises';
 import path from 'path';
 

tests/tests.pipeline.mock.test.mjs

@@ -0,0 +1,127 @@
+// tests/pipeline.mock.test.mjs
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+// --- Mocks ---
+// retrieval
+vi.mock('../src/retrieval/retrieval.mjs', () => {
+  return {
+    hybridSearch: vi.fn(async (query, k) => {
+      return [
+        { id: 'c1', content: `ctx for ${query}`, score: 1.0 },
+        { id: 'c2', content: `more ctx for ${query}`, score: 0.9 },
+      ].slice(0, k);
+    }),
+  };
+});
+
+// provider
+const mockProvider = {
+  generate: vi.fn(),
+};
+
+vi.mock('../src/providers/provider.mjs', () => {
+  return {
+    loadProvider: vi.fn(() => mockProvider),
+  };
+});
+
+// generator
+const mockGenResult = { ok: true, sample: { answer: 'A' } };
+vi.mock('../src/generator/generator_core.mjs', () => {
+  return {
+    runGenerator: vi.fn(async () => mockGenResult),
+  };
+});
+
+// verifier
+const mockVerResult = { ok: true };
+vi.mock('../src/verifier/verifier_core.mjs', () => {
+  return {
+    runVerifier: vi.fn(async () => mockVerResult),
+  };
+});
+
+// reward
+const mockRewResult = { ok: true, score: 0.9 };
+vi.mock('../src/reward/reward_core.mjs', () => {
+  return {
+    runReward: vi.fn(async () => mockRewResult),
+  };
+});
+
+// --- Import after mocks ---
+import {
+  runPipelineStep,
+  runPipelineBatch,
+  loadSeedQuestions,
+  seedToQuestion,
+  appendGoldRecord,
+} from '../src/pipeline/pipeline.mjs';
+
+describe('pipeline.mjs', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('seedToQuestion extracts question from various shapes', () => {
+    expect(seedToQuestion('raw')).toBe('raw');
+    expect(seedToQuestion({ question: 'q1' })).toBe('q1');
+    expect(seedToQuestion({ prompt: 'q2' })).toBe('q2');
+    expect(seedToQuestion({ text: 'q3' })).toBe('q3');
+  });
+
+  it('runPipelineStep returns accepted with mocked deps', async () => {
+    const res = await runPipelineStep({
+      question: 'What is service to others?',
+    });
+
+    expect(res.status).toBe('accepted');
+    expect(res.question).toBe('What is service to others?');
+    expect(Array.isArray(res.context)).toBe(true);
+    expect(res.gen).toEqual(mockGenResult);
+    expect(res.ver).toEqual(mockVerResult);
+    expect(res.rew).toEqual(mockRewResult);
+  });
+
+  it('runPipelineBatch processes seeds and writes JSONL', async () => {
+    const tmpDir = await fs.mkdtemp(
+      path.join(os.tmpdir(), 'distill-pipeline-test-'),
+    );
+
+    const seedsPath = path.join(tmpDir, 'seeds.jsonl');
+    const outPath = path.join(tmpDir, 'out.jsonl');
+
+    const seedsJsonl = [
+      JSON.stringify({ question: 'q1' }),
+      JSON.stringify({ prompt: 'q2' }),
+      JSON.stringify('q3'),
+    ].join('\n');
+
+    await fs.writeFile(seedsPath, seedsJsonl + '\n', 'utf8');
+
+    const summary = await runPipelineBatch({
+      seedsPath,
+      outPath,
+      limit: 3,
+    });
+
+    expect(summary.processed).toBe(3);
+    expect(summary.accepted).toBe(3);
+    expect(summary.outPath).toBe(outPath);
+
+    const outText = await fs.readFile(outPath, 'utf8');
+    const lines = outText.trim().split('\n');
+    expect(lines.length).toBe(3);
+
+    const first = JSON.parse(lines[0]);
+    expect(first).toHaveProperty('question');
+    expect(first).toHaveProperty('context');
+    expect(first).toHaveProperty('sample');
+    expect(first).toHaveProperty('verifier');
+    expect(first).toHaveProperty('reward');
+  });
+});