@kernel.chat/kbot 3.97.4 → 3.98.0

package/dist/train-curate.js

@@ -0,0 +1,354 @@
+// Training data curator — reads teacher traces and ~/.kbot/observer/session.jsonl,
+// scores + filters examples, emits a clean JSONL ready for fine-tuning.
+//
+// Scoring signals:
+//   + response length is reasonable (100–8000 tokens)
+//   + contained a thinking block (for reasoning distill)
+//   + tool calls had no error results
+//   + outcome.verified === true (if tagged)
+//   − user retried or gave negative feedback
+//   − response contained "I don't know" / "I can't help"
+//   − near-duplicate of another example (hash-based)
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, readdirSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
+const NEG_PATTERNS = [
+    /\bi (don'?t|do not) (know|have that|have access)\b/i,
+    /\bi (can'?t|cannot) (help|assist|do)\b/i,
+    /\bas an ai\b/i,
+    /\bi'?m sorry,? but\b/i,
+    /\bi apologi[sz]e\b/i,
+];
+function hashText(text) {
+    return createHash('sha256').update(text.slice(0, 2000).toLowerCase().replace(/\s+/g, ' ').trim()).digest('hex').slice(0, 16);
+}
+function scoreExample(ex, mode) {
+    let score = 0.5;
+    const reasons = [];
+    const lastAssistant = [...ex.messages].reverse().find(m => m.role === 'assistant')?.content || '';
+    const lastUser = [...ex.messages].reverse().find(m => m.role === 'user')?.content || '';
+    const respLen = lastAssistant.length;
+    // Length signal
+    if (respLen >= 200 && respLen <= 8000) {
+        score += 0.15;
+        reasons.push('good_length');
+    }
+    if (respLen < 80) {
+        score -= 0.3;
+        reasons.push('too_short');
+    }
+    if (respLen > 16000) {
+        score -= 0.15;
+        reasons.push('too_long');
+    }
+    // Refusal / low-effort signal
+    for (const pat of NEG_PATTERNS) {
+        if (pat.test(lastAssistant)) {
+            score -= 0.25;
+            reasons.push('refusal_like');
+            break;
+        }
+    }
+    // Mode-specific scoring
+    if (mode === 'reasoning') {
+        if (ex.thinking && ex.thinking.length > 100) {
+            score += 0.25;
+            reasons.push('has_thinking');
+        }
+        else {
+            score -= 0.2;
+            reasons.push('no_thinking');
+        }
+    }
+    if (mode === 'agent-trace') {
+        if (ex.tool_calls && ex.tool_calls.length > 0) {
+            score += 0.25;
+            reasons.push('has_tool_calls');
+        }
+        else {
+            score -= 0.3;
+            reasons.push('no_tool_calls');
+        }
+    }
+    if (mode === 'code-only') {
+        if (/```[a-zA-Z]+/.test(lastAssistant)) {
+            score += 0.15;
+            reasons.push('has_code_block');
+        }
+        if (/\b(function|class|import|const|def|fn )\b/.test(lastAssistant)) {
+            score += 0.1;
+            reasons.push('code_keywords');
+        }
+    }
+    // Outcome-tagged verified example
+    if (ex.outcome?.verified) {
+        score += 0.3;
+        reasons.push('verified');
+    }
+    if (ex.outcome?.signal === 'user_retry') {
+        score -= 0.4;
+        reasons.push('user_retried');
+    }
+    if (ex.outcome?.signal === 'build_pass' || ex.outcome?.signal === 'test_pass') {
+        score += 0.35;
+        reasons.push(ex.outcome.signal);
+    }
+    // Interaction quality
+    if (lastUser.length > 20 && lastUser.length < 4000) {
+        score += 0.05;
+        reasons.push('good_prompt_len');
+    }
+    return { score: Math.max(0, Math.min(1, score)), reasons };
+}
+/** Parse a single line from teacher/traces.jsonl into a normalized Example. */
+function parseTeacherLine(line) {
+    try {
+        const t = JSON.parse(line);
+        const messages = t.messages || [];
+        const response = t.response;
+        if (!response?.content || messages.length === 0)
+            return null;
+        return {
+            messages: [...messages, { role: 'assistant', content: response.content }],
+            thinking: response.thinking,
+            tool_calls: response.tool_calls,
+            outcome: t.outcome,
+            meta: { source: 'teacher', provider: t.provider, model: t.model, ts: t.ts },
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Parse ~/.kbot/observer/session.jsonl. Shape varies; be permissive. */
+function parseObserverLine(line) {
+    try {
+        const o = JSON.parse(line);
+        // Expected fields: input/output or user/assistant or prompt/response
+        const user = (o.input || o.user || o.prompt || o.query);
+        const assistant = (o.output || o.assistant || o.response || o.answer);
+        if (!user || !assistant || typeof user !== 'string' || typeof assistant !== 'string')
+            return null;
+        return {
+            messages: [
+                { role: 'user', content: user },
+                { role: 'assistant', content: assistant },
+            ],
+            meta: { source: 'observer', ts: o.ts },
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function extractContent(raw) {
+    if (typeof raw === 'string')
+        return raw;
+    if (Array.isArray(raw)) {
+        return raw.map(b => (b && typeof b === 'object' && 'text' in b) ? String(b.text || '') : '').join('\n');
+    }
+    return '';
+}
+function parseClaudeCodeFile(filePath) {
+    let lines;
+    try {
+        lines = readFileSync(filePath, 'utf-8').split('\n').filter(l => l.trim());
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    let pendingUser = null;
+    for (const line of lines) {
+        let turn;
+        try {
+            turn = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (turn.type === 'user' && turn.message) {
+            const content = extractContent(turn.message.content);
+            if (content.length > 10 && !content.startsWith('<tool_result'))
+                pendingUser = content;
+        }
+        else if (turn.type === 'assistant' && turn.message && pendingUser) {
+            const content = extractContent(turn.message.content);
+            if (content.length > 40) {
+                out.push({
+                    messages: [
+                        { role: 'user', content: pendingUser },
+                        { role: 'assistant', content },
+                    ],
+                    meta: { source: 'claude-code', session: turn.sessionId, file: filePath },
+                });
+                pendingUser = null;
+            }
+        }
+    }
+    return out;
+}
+function findClaudeCodeSessions(limitFiles = 40, maxDepth = 4) {
+    const base = join(homedir(), '.claude', 'projects');
+    if (!existsSync(base))
+        return [];
+    const files = [];
+    function walk(dir, depth) {
+        if (depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.startsWith('.') || entry === 'node_modules')
+                continue;
+            const full = join(dir, entry);
+            let st;
+            try {
+                st = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                walk(full, depth + 1);
+                continue;
+            }
+            if (entry.endsWith('.jsonl') && st.size > 2048)
+                files.push({ path: full, size: st.size });
+        }
+    }
+    try {
+        walk(base, 0);
+    }
+    catch {
+        return [];
+    }
+    files.sort((a, b) => b.size - a.size);
+    return files.slice(0, limitFiles).map(f => f.path);
+}
+function defaultSources(includeClaudeCode = true) {
+    const home = homedir();
+    const list = [
+        join(home, '.kbot', 'teacher', 'traces.jsonl'),
+        join(home, '.kbot', 'teacher', 'corrections.jsonl'),
+        join(home, '.kbot', 'observer', 'session.jsonl'),
+    ].filter(p => existsSync(p));
+    if (includeClaudeCode)
+        list.push(...findClaudeCodeSessions());
+    return list;
+}
+function readLines(file) {
+    try {
+        return readFileSync(file, 'utf-8').split('\n').filter(l => l.trim().length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+function parseSource(file) {
+    if (file.includes('/.claude/projects/'))
+        return parseClaudeCodeFile(file);
+    const lines = readLines(file);
+    if (file.includes('teacher') || file.includes('corrections'))
+        return lines.map(parseTeacherLine).filter((x) => x !== null);
+    if (file.includes('observer'))
+        return lines.map(parseObserverLine).filter((x) => x !== null);
+    const out = [];
+    for (const line of lines) {
+        const t = parseTeacherLine(line) || parseObserverLine(line);
+        if (t)
+            out.push(t);
+    }
+    return out;
+}
+/** Run the curator end-to-end. Returns a report. */
+export function curate(opts = {}) {
+    const mode = opts.mode ?? 'default';
+    const sources = opts.sources ?? defaultSources();
+    const output = resolve(opts.output ?? join(homedir(), '.kbot', 'teacher', `dataset-${mode}.jsonl`));
+    const maxExamples = opts.maxExamples ?? 5000;
+    const minScore = opts.minScore ?? 0.5;
+    const minResp = opts.minResponseLen ?? 80;
+    const maxResp = opts.maxResponseLen ?? 32000;
+    const dedupe = opts.dedupe !== false;
+    const outDir = output.substring(0, output.lastIndexOf('/'));
+    if (outDir && !existsSync(outDir))
+        mkdirSync(outDir, { recursive: true });
+    const bySource = {};
+    const all = [];
+    const seen = new Set();
+    let total = 0;
+    let duplicates = 0;
+    for (const src of sources) {
+        const examples = parseSource(src);
+        bySource[src] = examples.length;
+        for (const ex of examples) {
+            total++;
+            const lastAssistant = [...ex.messages].reverse().find(m => m.role === 'assistant')?.content || '';
+            if (lastAssistant.length < minResp || lastAssistant.length > maxResp)
+                continue;
+            const hash = hashText(ex.messages.map(m => m.content).join('|'));
+            if (dedupe && seen.has(hash)) {
+                duplicates++;
+                continue;
+            }
+            seen.add(hash);
+            const { score, reasons } = scoreExample(ex, mode);
+            if (score < minScore)
+                continue;
+            all.push({ ...ex, score, hash, reasons });
+        }
+    }
+    // Sort by score desc, cap
+    all.sort((a, b) => b.score - a.score);
+    const kept = all.slice(0, maxExamples);
+    // Emit as JSONL with OpenAI-style {messages: [...]} format that train_prepare understands
+    if (existsSync(output))
+        writeFileSync(output, ''); // truncate
+    for (const ex of kept) {
+        const record = { messages: ex.messages };
+        if (ex.thinking)
+            record.thinking = ex.thinking;
+        if (ex.tool_calls)
+            record.tool_calls = ex.tool_calls;
+        record._score = ex.score;
+        record._reasons = ex.reasons;
+        appendFileSync(output, JSON.stringify(record) + '\n');
+    }
+    const meanScore = kept.length > 0 ? kept.reduce((s, e) => s + e.score, 0) / kept.length : 0;
+    return {
+        output,
+        total_examined: total,
+        kept: kept.length,
+        rejected: total - kept.length - duplicates,
+        duplicates,
+        mean_score: Math.round(meanScore * 1000) / 1000,
+        by_source: bySource,
+    };
+}
+/** Format as a human-readable report */
+export function formatCurateReport(r) {
+    const lines = [
+        `Curate Report`,
+        `${'─'.repeat(40)}`,
+        `  Output:         ${r.output}`,
+        `  Examined:       ${r.total_examined}`,
+        `  Kept:           ${r.kept}`,
+        `  Rejected:       ${r.rejected}`,
+        `  Duplicates:     ${r.duplicates}`,
+        `  Mean score:     ${r.mean_score.toFixed(3)}`,
+        '',
+        `  Sources:`,
+    ];
+    for (const [src, count] of Object.entries(r.by_source)) {
+        lines.push(`    ${count.toString().padStart(6)}  ${src}`);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=train-curate.js.map

package/dist/train-cycle.d.ts

@@ -0,0 +1,22 @@
+export interface TrainCycleOptions {
+    studentModel?: string;
+    teacherProvider?: 'anthropic' | 'openai';
+    teacherModel?: string;
+    promptsFile?: string;
+    corrections?: string;
+    samples?: number;
+    passThreshold?: number;
+    retrain?: boolean;
+    dryRun?: boolean;
+}
+export interface CycleResult {
+    sampled: number;
+    passed: number;
+    corrected: number;
+    skipped: number;
+    corrections_file: string;
+    retrain_summary?: string;
+}
+export declare function runCycle(opts?: TrainCycleOptions): Promise<CycleResult>;
+export declare function formatCycleReport(r: CycleResult): string;
+//# sourceMappingURL=train-cycle.d.ts.map

package/dist/train-cycle.js

@@ -0,0 +1,230 @@
+// train-cycle — on-policy distillation loop (DeepSeek-R1 Distill pattern).
+//
+// Loop:
+//   1. Sample N prompts from held-out pool (~/.kbot/teacher/prompts.jsonl)
+//   2. Student (local model) generates response
+//   3. Teacher (Claude) grades; if bad, teacher writes a corrected response
+//   4. Pairs go back into ~/.kbot/teacher/corrections.jsonl
+//   5. Optionally retrain via train-self --mode default (with corrections merged)
+//
+// Designed to run as a weekly cron or on-demand.
+import { existsSync, readFileSync, appendFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+function readPrompts(file) {
+    if (!existsSync(file))
+        return [];
+    return readFileSync(file, 'utf-8')
+        .split('\n')
+        .filter(l => l.trim())
+        .map(l => { try {
+        return JSON.parse(l);
+    }
+    catch {
+        return null;
+    } })
+        .filter((x) => x !== null && typeof x.prompt === 'string');
+}
+/** Auto-harvest prompts from teacher/traces.jsonl (user messages) if no explicit file. */
+function harvestPrompts(limit = 200) {
+    const traceFile = join(homedir(), '.kbot', 'teacher', 'traces.jsonl');
+    if (!existsSync(traceFile))
+        return [];
+    const lines = readFileSync(traceFile, 'utf-8').split('\n').filter(l => l.trim());
+    const out = [];
+    for (const line of lines.slice(-limit * 2)) {
+        try {
+            const t = JSON.parse(line);
+            const msgs = t.messages;
+            const firstUser = msgs?.find(m => m.role === 'user');
+            if (firstUser && firstUser.content.length > 20 && firstUser.content.length < 2000) {
+                out.push({ prompt: firstUser.content, system: t.system });
+            }
+            if (out.length >= limit)
+                break;
+        }
+        catch { /* skip */ }
+    }
+    return out;
+}
+async function callOllama(model, system, prompt) {
+    const res = await fetch('http://localhost:11434/api/chat', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            model,
+            stream: false,
+            messages: [
+                ...(system ? [{ role: 'system', content: system }] : []),
+                { role: 'user', content: prompt },
+            ],
+            options: { num_predict: 2048, temperature: 0.2 },
+        }),
+        signal: AbortSignal.timeout(300_000),
+    });
+    if (!res.ok)
+        throw new Error(`Ollama HTTP ${res.status}`);
+    const data = await res.json();
+    return data.message?.content || '';
+}
+async function callAnthropicGrade(apiKey, teacherModel, system, prompt, studentResponse) {
+    const gradePrompt = `You are grading a student AI's response. Score 0.0–1.0 based on correctness, completeness, and helpfulness.
+
+If the response scores below 0.6, provide a corrected response.
+
+Return ONLY valid JSON in this exact shape:
+{"score": <number>, "rationale": "<one sentence>", "correction": "<corrected response or empty string>"}
+
+ORIGINAL PROMPT:
+${prompt.slice(0, 4000)}
+
+STUDENT RESPONSE:
+${studentResponse.slice(0, 6000)}`;
+    const res = await fetch('https://api.anthropic.com/v1/messages', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify({
+            model: teacherModel,
+            max_tokens: 4096,
+            system: system || 'You are a strict code/AI grader.',
+            messages: [{ role: 'user', content: gradePrompt }],
+        }),
+        signal: AbortSignal.timeout(120_000),
+    });
+    if (!res.ok)
+        throw new Error(`Anthropic HTTP ${res.status}`);
+    const data = await res.json();
+    const text = (data.content || []).filter(b => b.type === 'text').map(b => b.text).join('');
+    // Extract JSON from response
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (!jsonMatch)
+        return { score: 0, rationale: 'no JSON in response', correction: undefined };
+    try {
+        const parsed = JSON.parse(jsonMatch[0]);
+        return {
+            score: typeof parsed.score === 'number' ? parsed.score : 0,
+            rationale: parsed.rationale || '',
+            correction: parsed.correction || undefined,
+        };
+    }
+    catch {
+        return { score: 0, rationale: 'JSON parse failed', correction: undefined };
+    }
+}
+export async function runCycle(opts = {}) {
+    const studentModel = opts.studentModel ?? 'kernel-coder:latest';
+    const teacherProvider = opts.teacherProvider ?? 'anthropic';
+    const teacherModel = opts.teacherModel ?? 'claude-opus-4-6';
+    const promptsFile = opts.promptsFile ?? join(homedir(), '.kbot', 'teacher', 'prompts.jsonl');
+    const correctionsFile = opts.corrections ?? join(homedir(), '.kbot', 'teacher', 'corrections.jsonl');
+    const samples = opts.samples ?? 50;
+    const threshold = opts.passThreshold ?? 0.6;
+    let prompts = readPrompts(promptsFile);
+    if (prompts.length === 0)
+        prompts = harvestPrompts(samples * 3);
+    if (prompts.length === 0) {
+        return {
+            sampled: 0, passed: 0, corrected: 0, skipped: 0,
+            corrections_file: correctionsFile,
+        };
+    }
+    // Shuffle + take N
+    prompts = prompts.sort(() => Math.random() - 0.5).slice(0, samples);
+    let passed = 0, corrected = 0, skipped = 0;
+    // Pull teacher API key
+    let teacherKey = '';
+    if (teacherProvider === 'anthropic') {
+        teacherKey = process.env.ANTHROPIC_API_KEY || '';
+        if (!teacherKey) {
+            try {
+                const cfg = JSON.parse(readFileSync(join(homedir(), '.kbot', 'config.json'), 'utf-8'));
+                teacherKey = cfg.anthropic_api_key || cfg.anthropicApiKey || '';
+            }
+            catch { /* no config */ }
+        }
+        if (!teacherKey)
+            throw new Error('No Anthropic API key for teacher. Set ANTHROPIC_API_KEY or run `kbot auth`.');
+    }
+    for (const p of prompts) {
+        try {
+            const studentResp = await callOllama(studentModel, p.system || '', p.prompt);
+            if (!studentResp || studentResp.length < 20) {
+                skipped++;
+                continue;
+            }
+            if (opts.dryRun) {
+                passed++;
+                continue;
+            }
+            const grade = await callAnthropicGrade(teacherKey, teacherModel, p.system || '', p.prompt, studentResp);
+            if (grade.score >= threshold) {
+                passed++;
+                // Keep good student responses as training examples too
+                appendFileSync(correctionsFile, JSON.stringify({
+                    messages: [
+                        ...(p.system ? [{ role: 'system', content: p.system }] : []),
+                        { role: 'user', content: p.prompt },
+                        { role: 'assistant', content: studentResp },
+                    ],
+                    _score: grade.score,
+                    _source: 'student_passed',
+                }) + '\n');
+            }
+            else if (grade.correction) {
+                corrected++;
+                appendFileSync(correctionsFile, JSON.stringify({
+                    messages: [
+                        ...(p.system ? [{ role: 'system', content: p.system }] : []),
+                        { role: 'user', content: p.prompt },
+                        { role: 'assistant', content: grade.correction },
+                    ],
+                    _score: 1.0,
+                    _source: 'teacher_corrected',
+                    _student_score: grade.score,
+                    _rationale: grade.rationale,
+                }) + '\n');
+            }
+            else {
+                skipped++;
+            }
+        }
+        catch {
+            skipped++;
+        }
+    }
+    let retrainSummary;
+    if (opts.retrain && !opts.dryRun) {
+        const { trainSelf, formatTrainSelfReport } = await import('./train-self.js');
+        // Merge corrections into next dataset: curator picks them up from ~/.kbot/teacher/
+        const r = await trainSelf({ mode: 'default' });
+        retrainSummary = formatTrainSelfReport(r);
+    }
+    return {
+        sampled: prompts.length,
+        passed,
+        corrected,
+        skipped,
+        corrections_file: correctionsFile,
+        retrain_summary: retrainSummary,
+    };
+}
+export function formatCycleReport(r) {
+    const lines = [
+        'train-cycle',
+        '─'.repeat(40),
+        `  Sampled:      ${r.sampled}`,
+        `  Passed:       ${r.passed}  (student got it right)`,
+        `  Corrected:    ${r.corrected}  (teacher rewrote)`,
+        `  Skipped:      ${r.skipped}`,
+        `  Corrections:  ${r.corrections_file}`,
+    ];
+    if (r.retrain_summary) {
+        lines.push('', 'Retrain:', r.retrain_summary);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=train-cycle.js.map

package/dist/train-grpo.d.ts

@@ -0,0 +1,68 @@
+export type Verifier = {
+    kind: 'build-pass';
+    cwd: string;
+    cmd: string;
+} | {
+    kind: 'test-pass';
+    cwd: string;
+    cmd: string;
+} | {
+    kind: 'lint-pass';
+    cwd: string;
+    cmd: string;
+} | {
+    kind: 'regex-match';
+    pattern: string;
+    flags?: string;
+} | {
+    kind: 'json-valid';
+    requireKeys?: string[];
+} | {
+    kind: 'custom';
+    script: string;
+};
+export interface GrpoPrompt {
+    id?: string;
+    prompt: string;
+    system?: string;
+    verifier: Verifier;
+    tags?: string[];
+}
+export interface GrpoOptions {
+    studentModel?: string;
+    prompts: GrpoPrompt[];
+    groupSize?: number;
+    iters?: number;
+    learningRate?: number;
+    klBeta?: number;
+    outputDir?: string;
+    runnerCmd?: string;
+    dryRun?: boolean;
+}
+export interface RolloutResult {
+    prompt_id: string;
+    completions: Array<{
+        text: string;
+        reward: number;
+        verifier_ok: boolean;
+    }>;
+    advantage: number[];
+}
+export interface GrpoResult {
+    ok: boolean;
+    output_dir: string;
+    rollouts: RolloutResult[];
+    iterations_run: number;
+    mean_reward: number;
+    log: string;
+}
+/** Apply a verifier to a completion. Returns { ok, reward ∈ [0,1] }. */
+export declare function verify(v: Verifier, completion: string): Promise<{
+    ok: boolean;
+    reward: number;
+}>;
+export declare function runGrpoRollouts(opts: GrpoOptions): Promise<GrpoResult>;
+/** Default verifier suite for kbot: regex + JSON validity on common code gen. */
+export declare const DEFAULT_VERIFIER_SUITE: GrpoPrompt[];
+export declare function formatGrpoReport(r: GrpoResult): string;
+//# sourceMappingURL=train-grpo.d.ts.map