klyro 0.1.4 → 0.1.5

package/dist/cli/trace.js

@@ -0,0 +1,63 @@
+/**
+ * 3.1 — klyro trace <session> pretty-print, --stats
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+async function readTraceFile(sessionId) {
+    // Try trace writer path first: .klyro/traces/<id>.jsonl
+    const tracePath = path.join(process.cwd(), '.klyro', 'traces', `${sessionId}.jsonl`);
+    try {
+        const raw = await fs.readFile(tracePath, 'utf-8');
+        return raw.split('\n').filter(Boolean).map((l) => JSON.parse(l));
+    }
+    catch {
+        // Fallback to session store messages
+        const { getDefaultSessionStore } = await import('../persistence/session.js');
+        const store = getDefaultSessionStore();
+        const msgs = await store.loadMessages(sessionId);
+        return msgs;
+    }
+}
+export async function runTrace(sessionId, opts = {}) {
+    const { getDefaultSessionStore, resolveSessionId } = await import('../persistence/session.js');
+    const store = getDefaultSessionStore();
+    const full = await resolveSessionId(store, sessionId);
+    if (!full) {
+        // Try direct trace file
+        const events = await readTraceFile(sessionId);
+        if (events.length > 0) {
+            if (opts.json)
+                process.stdout.write(JSON.stringify(events, null, 2) + '\n');
+            else
+                for (const ev of events)
+                    process.stdout.write(JSON.stringify(ev) + '\n');
+            return 0;
+        }
+        process.stderr.write(`session/trace not found: ${sessionId}\n`);
+        return 2;
+    }
+    const events = await readTraceFile(full);
+    if (opts.stats) {
+        const byType = {};
+        for (const ev of events) {
+            const t = ev.type ?? 'unknown';
+            byType[t] = (byType[t] ?? 0) + 1;
+        }
+        const out = { sessionId: full, total: events.length, byType };
+        process.stdout.write(JSON.stringify(out, null, 2) + '\n');
+        return 0;
+    }
+    if (opts.json) {
+        process.stdout.write(JSON.stringify(events, null, 2) + '\n');
+    }
+    else {
+        for (const ev of events) {
+            const e = ev;
+            if (e.type === 'stream.delta' && e.text)
+                process.stdout.write(e.text);
+            else
+                process.stdout.write(JSON.stringify(ev) + '\n');
+        }
+    }
+    return 0;
+}

package/dist/cli/update.d.ts

@@ -0,0 +1,6 @@
+/**
+ * klyro update — check registry for newer version, cached 24h.
+ * Env KLYRO_NO_UPDATE_CHECK=1 disables.
+ */
+export declare function checkForUpdate(current: string): Promise<string | null>;
+export declare function runUpdate(): Promise<number>;

package/dist/cli/update.js

@@ -0,0 +1,70 @@
+/**
+ * klyro update — check registry for newer version, cached 24h.
+ * Env KLYRO_NO_UPDATE_CHECK=1 disables.
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+function cachePath() {
+    const home = os.homedir() || process.cwd();
+    return path.join(home, '.klyro', 'update-cache.json');
+}
+export async function checkForUpdate(current) {
+    if (process.env.KLYRO_NO_UPDATE_CHECK === '1')
+        return null;
+    const cache = cachePath();
+    try {
+        const raw = await fs.readFile(cache, 'utf-8');
+        const data = JSON.parse(raw);
+        if (Date.now() - data.at < CACHE_TTL_MS) {
+            return data.latest !== current ? data.latest : null;
+        }
+    }
+    catch {
+        // ignore
+    }
+    try {
+        const ctrl = new AbortController();
+        const t = setTimeout(() => ctrl.abort(), 3000);
+        const res = await fetch('https://registry.npmjs.org/klyro/latest', { signal: ctrl.signal });
+        clearTimeout(t);
+        if (!res.ok)
+            return null;
+        const json = (await res.json());
+        const latest = json.version ?? '';
+        await fs.mkdir(path.dirname(cache), { recursive: true });
+        await fs.writeFile(cache, JSON.stringify({ at: Date.now(), latest }), 'utf-8');
+        if (latest && latest !== current)
+            return latest;
+    }
+    catch {
+        // network failure — silent
+    }
+    return null;
+}
+export async function runUpdate() {
+    const here = await import('../index.js').then(() => '');
+    // Get version from package.json via dynamic import
+    const { readFileSync } = await import('node:fs');
+    const { resolve, dirname } = await import('node:path');
+    const { fileURLToPath } = await import('node:url');
+    try {
+        const pkgPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        const cur = pkg.version ?? '0.0.0';
+        const latest = await checkForUpdate(cur);
+        if (latest) {
+            process.stdout.write(`Update available: ${cur} → ${latest}\n  npm i -g klyro@latest\n`);
+        }
+        else {
+            process.stdout.write(`klyro ${cur} is latest\n`);
+        }
+        return 0;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`klyro update: ${msg}\n`);
+        return 1;
+    }
+}

package/dist/context/system-prompt.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 2.3 — Layered system prompt (stable first): identity → environment → global instructions
+ */
+export declare function buildSystemPrompt(opts: {
+    cwd: string;
+    model: string;
+    extraSystem?: string;
+    appendSystem?: string;
+    thinkingEnabled?: boolean;
+}): string;
+export declare function parseImageInput(text: string): {
+    text: string;
+    images: string[];
+};

package/dist/context/system-prompt.js

@@ -0,0 +1,47 @@
+/**
+ * 2.3 — Layered system prompt (stable first): identity → environment → global instructions
+ */
+import * as os from 'node:os';
+import { spawnSync } from 'node:child_process';
+function getBranch(cwd) {
+    try {
+        const r = spawnSync('git', ['branch', '--show-current'], { cwd, encoding: 'utf-8', timeout: 800, windowsHide: true });
+        if (r.status === 0)
+            return r.stdout.trim();
+    }
+    catch { /* ignore */ }
+    return '';
+}
+export function buildSystemPrompt(opts) {
+    const identity = `You are Klyro, an autonomous coding harness. You solve the user's task by calling tools in a loop. Prefer the smallest change that solves the task. When you have finished, produce a short final text answer (no tool calls). Do not invent file paths. Do not call tools outside the working directory.`;
+    const env = [
+        `OS: ${os.type()} ${os.release()} ${os.arch()}`,
+        `Shell: ${process.env.SHELL ?? process.env.COMSPEC ?? 'unknown'}`,
+        `CWD: ${opts.cwd}`,
+        `Date: ${new Date().toISOString().slice(0, 10)}`,
+        `Branch: ${getBranch(opts.cwd) || '(no git)'}`,
+        `Model: ${opts.model}`,
+    ].join('\n');
+    const global = `Global instructions: Be concise, verify after edits, and never say "Done" without running verification.`;
+    const parts = [identity, `Environment:\n${env}`, global];
+    if (opts.extraSystem)
+        parts.splice(1, 0, opts.extraSystem);
+    if (opts.appendSystem)
+        parts.push(opts.appendSystem);
+    if (opts.thinkingEnabled)
+        parts.push('Thinking: enabled — use internal reasoning before tool calls.');
+    return parts.join('\n\n');
+}
+export function parseImageInput(text) {
+    // Handle @img.png, drag-drop path, clipboard stub
+    const images = [];
+    const imgRe = /@([^\s]+\.(png|jpg|jpeg|gif|webp))/gi;
+    let m;
+    while ((m = imgRe.exec(text))) {
+        if (m[1])
+            images.push(m[1]);
+    }
+    // Remove @img refs from text for now (real impl would attach as image block)
+    const clean = text.replace(imgRe, '').trim();
+    return { text: clean, images };
+}

package/dist/events/bus.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 3.1 — core/events emitter
+ * In-memory pub/sub for KlyroEvents. Sync delivery, no buffering.
+ */
+import type { KlyroEvent } from './catalog.js';
+type Listener = (ev: KlyroEvent) => void;
+export declare class EventBus {
+    private listeners;
+    private history;
+    emit(ev: KlyroEvent): void;
+    on(listener: Listener): () => void;
+    getHistory(): KlyroEvent[];
+    clear(): void;
+}
+export declare const globalBus: EventBus;
+export {};

package/dist/events/bus.js

@@ -0,0 +1,28 @@
+/**
+ * 3.1 — core/events emitter
+ * In-memory pub/sub for KlyroEvents. Sync delivery, no buffering.
+ */
+export class EventBus {
+    listeners = new Set();
+    history = [];
+    emit(ev) {
+        this.history.push(ev);
+        for (const l of [...this.listeners]) {
+            try {
+                l(ev);
+            }
+            catch { /* ignore listener error */ }
+        }
+    }
+    on(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    getHistory() {
+        return [...this.history];
+    }
+    clear() {
+        this.history = [];
+    }
+}
+export const globalBus = new EventBus();

package/dist/events/catalog.d.ts

@@ -0,0 +1,136 @@
+/**
+ * 3.1 — KlyroEvent catalog (Appendix C)
+ * Every observable action in the harness is a typed event.
+ */
+export type KlyroEvent = {
+    type: 'session.start';
+    ts: number;
+    sessionId: string;
+    task: string;
+    cwd: string;
+    model: string;
+} | {
+    type: 'session.end';
+    ts: number;
+    sessionId: string;
+    status: string;
+    durationMs: number;
+} | {
+    type: 'turn.start';
+    ts: number;
+    sessionId: string;
+    turn: number;
+    model: string;
+} | {
+    type: 'turn.end';
+    ts: number;
+    sessionId: string;
+    turn: number;
+    finishReason?: string;
+} | {
+    type: 'stream.delta';
+    ts: number;
+    sessionId: string;
+    text: string;
+} | {
+    type: 'stream.thinking';
+    ts: number;
+    sessionId: string;
+    text: string;
+} | {
+    type: 'tool.call';
+    ts: number;
+    sessionId: string;
+    callId: string;
+    name: string;
+    input: unknown;
+} | {
+    type: 'tool.result';
+    ts: number;
+    sessionId: string;
+    callId: string;
+    name: string;
+    output: unknown;
+    isError: boolean;
+    latencyMs: number;
+} | {
+    type: 'permission.ask';
+    ts: number;
+    sessionId: string;
+    callId: string;
+    name: string;
+    reason?: string;
+} | {
+    type: 'permission.decision';
+    ts: number;
+    sessionId: string;
+    callId: string;
+    action: 'allow' | 'deny' | 'ask';
+    reason?: string;
+} | {
+    type: 'policy.decision';
+    ts: number;
+    sessionId: string;
+    callId: string;
+    name: string;
+    action: 'allow' | 'deny' | 'ask';
+    reason?: string;
+} | {
+    type: 'file.changed';
+    ts: number;
+    sessionId: string;
+    path: string;
+    op: 'created' | 'modified' | 'deleted';
+} | {
+    type: 'phase.changed';
+    ts: number;
+    sessionId: string;
+    phase: string;
+} | {
+    type: 'verification.started';
+    ts: number;
+    sessionId: string;
+    command: string;
+} | {
+    type: 'verification.succeeded';
+    ts: number;
+    sessionId: string;
+    command: string;
+} | {
+    type: 'verification.failed';
+    ts: number;
+    sessionId: string;
+    command: string;
+    reason: string;
+} | {
+    type: 'repair.started';
+    ts: number;
+    sessionId: string;
+    attempt: number;
+    maxAttempts: number;
+    reason: string;
+} | {
+    type: 'checkpoint.saved';
+    ts: number;
+    sessionId: string;
+} | {
+    type: 'usage';
+    ts: number;
+    sessionId: string;
+    input: number;
+    output: number;
+    cost?: number;
+} | {
+    type: 'error';
+    ts: number;
+    sessionId: string;
+    code: string;
+    message: string;
+    retryable?: boolean;
+} | {
+    type: 'abort';
+    ts: number;
+    sessionId: string;
+    reason: string;
+};
+export type KlyroEventType = KlyroEvent['type'];

package/dist/events/catalog.js

@@ -0,0 +1,5 @@
+/**
+ * 3.1 — KlyroEvent catalog (Appendix C)
+ * Every observable action in the harness is a typed event.
+ */
+export {};