@kernel.chat/kbot 3.97.4 → 3.99.0

package/dist/tools/idempotency-check.js

@@ -0,0 +1,31 @@
+// kbot Idempotency Check Tool — Prevent duplicate actions
+// This tool verifies if a task has already been executed to avoid unintended side effects.
+import { registerTool } from './index.js';
+export function registerIdempotencyTools() {
+    registerTool({
+        name: 'idempotency_check',
+        description: 'Checks if an action has already been performed based on a unique identifier. Returns true if the action has been done, false otherwise.',
+        parameters: {
+            identifier: { type: 'string', description: 'Unique identifier for the action', required: true },
+        },
+        tier: 'free',
+        async execute(args) {
+            const identifier = String(args.identifier);
+            // Simulate a database check (replace with actual DB query)
+            const hasRun = await simulateDatabaseCheck(identifier);
+            if (hasRun) {
+                return 'true';
+            }
+            else {
+                return 'false';
+            }
+        },
+    });
+}
+async function simulateDatabaseCheck(identifier) {
+    // Replace with actual database query logic
+    // This is a placeholder for demonstration purposes
+    console.log(`Simulating database check for identifier: ${identifier}`);
+    return false; // Assume not run for now
+}
+//# sourceMappingURL=idempotency-check.js.map

package/dist/tools/schedule-persistence.d.ts

@@ -0,0 +1,2 @@
+export declare function registerSchedulePersistenceTools(): void;
+//# sourceMappingURL=schedule-persistence.d.ts.map

package/dist/tools/schedule-persistence.js

@@ -0,0 +1,19 @@
+// kbot Schedule Persistence Tool — Reliable task scheduling
+import { registerTool } from './index.js';
+export function registerSchedulePersistenceTools() {
+    registerTool({
+        name: 'schedule_persist',
+        description: 'Persistently stores and retrieves schedules, ensuring tasks are executed even after interruptions.',
+        parameters: {
+            schedule: { type: 'string', description: 'The schedule to persist (JSON format)', required: true },
+        },
+        tier: 'pro',
+        async execute(args) {
+            const schedule = JSON.parse(String(args.schedule));
+            // Placeholder for persistence logic (replace with actual implementation)
+            console.log(`Persisting schedule: ${JSON.stringify(schedule)}`);
+            return 'Schedule persisted (implementation placeholder)';
+        },
+    });
+}
+//# sourceMappingURL=schedule-persistence.js.map

package/dist/train-agent-trace.d.ts

@@ -0,0 +1,29 @@
+export declare const TOOL_TOKENS: {
+    readonly think_open: "<think>";
+    readonly think_close: "</think>";
+    readonly tool_open: "<tool>";
+    readonly tool_close: "</tool>";
+    readonly args_open: "<args>";
+    readonly args_close: "</args>";
+    readonly result_open: "<result>";
+    readonly result_close: "</result>";
+    readonly answer_open: "<answer>";
+    readonly answer_close: "</answer>";
+};
+export interface AgentTraceOptions {
+    input?: string;
+    output?: string;
+    minTools?: number;
+    maxResultLen?: number;
+    verifiedOnly?: boolean;
+}
+export interface AgentTraceResult {
+    output: string;
+    trajectories: number;
+    examples: number;
+    skipped_no_tools: number;
+    skipped_errors: number;
+}
+export declare function formatAgentTraces(opts?: AgentTraceOptions): AgentTraceResult;
+export declare function formatAgentTraceReport(r: AgentTraceResult): string;
+//# sourceMappingURL=train-agent-trace.d.ts.map

package/dist/train-agent-trace.js

@@ -0,0 +1,141 @@
+// train-agent-trace — reformat multi-turn tool-use sessions into training examples
+// with explicit tool tokens. Used by train-self --mode agent-trace.
+//
+// Output format (one example per completed trajectory):
+//   {"messages": [
+//     {"role":"user","content":"..."},
+//     {"role":"assistant","content":"<think>...</think><tool>name</tool><args>{...}</args>"},
+//     {"role":"tool","content":"<result>...</result>"},
+//     {"role":"assistant","content":"<think>...</think><answer>...</answer>"}
+//   ]}
+//
+// Tool tokens we inject:
+//   <think>...</think>   — reasoning
+//   <tool>name</tool>    — tool selected
+//   <args>{...}</args>   — JSON arguments
+//   <result>...</result> — tool output (truncated)
+//   <answer>...</answer> — final assistant turn
+import { existsSync, readFileSync, writeFileSync, appendFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+export const TOOL_TOKENS = {
+    think_open: '<think>', think_close: '</think>',
+    tool_open: '<tool>', tool_close: '</tool>',
+    args_open: '<args>', args_close: '</args>',
+    result_open: '<result>', result_close: '</result>',
+    answer_open: '<answer>', answer_close: '</answer>',
+};
+function truncate(s, n) {
+    if (s.length <= n)
+        return s;
+    return s.slice(0, n) + ` …[+${s.length - n} chars]`;
+}
+/** Build an assistant turn with think + tool call tokens. */
+function assistantToolTurn(thinking, toolName, args) {
+    const thinkPart = thinking
+        ? `${TOOL_TOKENS.think_open}${thinking.trim()}${TOOL_TOKENS.think_close}\n`
+        : '';
+    const argsJson = JSON.stringify(args);
+    return `${thinkPart}${TOOL_TOKENS.tool_open}${toolName}${TOOL_TOKENS.tool_close}\n${TOOL_TOKENS.args_open}${argsJson}${TOOL_TOKENS.args_close}`;
+}
+/** Build a tool-result turn. */
+function toolResultTurn(result, maxLen) {
+    return `${TOOL_TOKENS.result_open}${truncate(result, maxLen)}${TOOL_TOKENS.result_close}`;
+}
+/** Build the final assistant answer turn. */
+function answerTurn(thinking, content) {
+    const thinkPart = thinking
+        ? `${TOOL_TOKENS.think_open}${thinking.trim()}${TOOL_TOKENS.think_close}\n`
+        : '';
+    return `${thinkPart}${TOOL_TOKENS.answer_open}${content.trim()}${TOOL_TOKENS.answer_close}`;
+}
+/** Convert one teacher trace into an agent-trace example. */
+function formatTrace(t, maxResult) {
+    const toolCalls = t.response.tool_calls || [];
+    if (toolCalls.length === 0)
+        return null;
+    const messages = [];
+    // Seed with conversation context (excluding the final assistant turn)
+    for (const m of t.messages) {
+        if (m.role === 'user' || m.role === 'system') {
+            messages.push({ role: m.role, content: m.content });
+        }
+    }
+    // Inject assistant tool-call turn
+    const firstCall = toolCalls[0];
+    messages.push({
+        role: 'assistant',
+        content: assistantToolTurn(t.response.thinking || '', firstCall.name, firstCall.arguments),
+    });
+    // We don't have the actual tool result in teacher traces — synthesize a placeholder
+    // that the model can learn to parse. In production, the tool executor would fill this
+    // when replaying recorded sessions.
+    messages.push({
+        role: 'tool',
+        content: toolResultTurn('[result from ' + firstCall.name + ']', maxResult),
+    });
+    // Final answer
+    messages.push({
+        role: 'assistant',
+        content: answerTurn('', t.response.content),
+    });
+    return {
+        messages,
+        _tool_count: toolCalls.length,
+        _trace_id: t.id,
+    };
+}
+export function formatAgentTraces(opts = {}) {
+    const input = opts.input ?? join(homedir(), '.kbot', 'teacher', 'traces.jsonl');
+    const output = opts.output ?? join(homedir(), '.kbot', 'teacher', 'dataset-agent-trace.jsonl');
+    const minTools = opts.minTools ?? 1;
+    const maxResult = opts.maxResultLen ?? 1200;
+    const result = {
+        output,
+        trajectories: 0,
+        examples: 0,
+        skipped_no_tools: 0,
+        skipped_errors: 0,
+    };
+    if (!existsSync(input))
+        return result;
+    // Truncate output
+    writeFileSync(output, '');
+    const lines = readFileSync(input, 'utf-8').split('\n').filter(l => l.trim());
+    for (const line of lines) {
+        try {
+            const t = JSON.parse(line);
+            result.trajectories++;
+            if (opts.verifiedOnly && !t.outcome?.verified) {
+                result.skipped_errors++;
+                continue;
+            }
+            const toolCount = t.response.tool_calls?.length || 0;
+            if (toolCount < minTools) {
+                result.skipped_no_tools++;
+                continue;
+            }
+            const ex = formatTrace(t, maxResult);
+            if (ex) {
+                appendFileSync(output, JSON.stringify(ex) + '\n');
+                result.examples++;
+            }
+        }
+        catch {
+            result.skipped_errors++;
+        }
+    }
+    return result;
+}
+export function formatAgentTraceReport(r) {
+    return [
+        'agent-trace formatter',
+        '─'.repeat(40),
+        `  Output:             ${r.output}`,
+        `  Trajectories seen:  ${r.trajectories}`,
+        `  Examples emitted:   ${r.examples}`,
+        `  Skipped (no tools): ${r.skipped_no_tools}`,
+        `  Skipped (errors):   ${r.skipped_errors}`,
+    ].join('\n');
+}
+//# sourceMappingURL=train-agent-trace.js.map

package/dist/train-curate.d.ts

@@ -0,0 +1,25 @@
+export type CurateMode = 'default' | 'reasoning' | 'agent-trace' | 'code-only';
+export interface CurateOptions {
+    sources?: string[];
+    output?: string;
+    mode?: CurateMode;
+    maxExamples?: number;
+    minScore?: number;
+    minResponseLen?: number;
+    maxResponseLen?: number;
+    dedupe?: boolean;
+}
+export interface CurateResult {
+    output: string;
+    total_examined: number;
+    kept: number;
+    rejected: number;
+    duplicates: number;
+    mean_score: number;
+    by_source: Record<string, number>;
+}
+/** Run the curator end-to-end. Returns a report. */
+export declare function curate(opts?: CurateOptions): CurateResult;
+/** Format as a human-readable report */
+export declare function formatCurateReport(r: CurateResult): string;
+//# sourceMappingURL=train-curate.d.ts.map

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