klyro 0.1.1

package/dist/cli/repl.js

@@ -0,0 +1,194 @@
+/**
+ * `klyro` (no args) — the TUI REPL.
+ *
+ * Loads config from env, builds the agent runtime deps, mounts the
+ * Ink app, and bridges RuntimeEvents to the app's transcript/status
+ * via the global hooks installed by App.useEffect.
+ */
+import React from 'react';
+import { render } from 'ink';
+import { App } from '../tui/app.js';
+import { httpChatAdapter } from '../agent/provider-adapter.js';
+import { run } from '../agent/runtime.js';
+import { builtinRegistry } from '../tools/registry.js';
+import { builtinRules, DEFAULT_POLICY_CONFIG, PolicyEngine } from '../policy/engine.js';
+import { buildLevel6Context } from '../context/level6.js';
+import { DenyAllApprovalPrompt, StdinApprovalPrompt } from '../policy/approval.js';
+function readEnv(name, fallback) {
+    const v = process.env[name];
+    return v && v.length > 0 ? v : fallback;
+}
+export async function startRepl(opts = {}) {
+    const baseUrl = readEnv('KLYRO_BASE_URL');
+    const apiKey = readEnv('KLYRO_API_KEY');
+    const model = opts.model ?? readEnv('KLYRO_MODEL');
+    if (!baseUrl || !apiKey || !model) {
+        process.stderr.write('klyro: KLYRO_BASE_URL, KLYRO_API_KEY, and KLYRO_MODEL must be set\n');
+        return 2;
+    }
+    const cwd = opts.cwd ?? process.cwd();
+    const registry = builtinRegistry();
+    const policy = new PolicyEngine(builtinRules(), DEFAULT_POLICY_CONFIG);
+    const adapter = httpChatAdapter({ baseURL: baseUrl, apiKey, timeoutMs: 60_000 });
+    const approval = opts.nonInteractive ? new DenyAllApprovalPrompt() : new StdinApprovalPrompt();
+    const ctxBlock = await buildLevel6Context({ cwd });
+    const ctxPrefix = ctxBlock.formatted ? `\n\n<context>\n${ctxBlock.formatted}\n</context>` : '';
+    const systemPromptFn = (_ctx) => {
+        const base = opts.systemPrompt ?? 'You are Klyro, an autonomous coding harness. Solve the user\'s task using the available tools.';
+        const t = _ctx.telemetry ? '\n\n' + _ctx.telemetry : '';
+        return base + ctxPrefix + t;
+    };
+    const ac = new AbortController();
+    process.on('SIGINT', () => ac.abort());
+    let inflight = null;
+    let transcriptRef = [];
+    let lastStatus = null;
+    const app = render(React.createElement(App, {
+        initialModel: model,
+        maxSteps: opts.maxSteps ?? 30,
+        initialStatus: { status: 'idle' },
+        onPrompt: async (text) => {
+            inflight = runWithBridge(text);
+            await inflight;
+            inflight = null;
+        },
+        onSlash: async (cmd) => {
+            await handleSlash(cmd);
+        },
+    }));
+    // Bridge: subscribes to global hooks installed by App.useEffect.
+    // Every time the runtime emits, we translate to a transcript item or
+    // a status update.
+    const appG = globalThis;
+    async function runWithBridge(text) {
+        appG.__klyroAppStatus?.({ status: 'running', step: 0 });
+        let textBuf = '';
+        let activeCallId = null;
+        let activeCallName = null;
+        let activeCallArgs = '';
+        try {
+            const result = await run({
+                task: text,
+                cwd,
+                model: model,
+                maxSteps: opts.maxSteps ?? 30,
+                signal: ac.signal,
+                nonInteractive: opts.nonInteractive ?? false,
+                onEvent: (ev) => {
+                    if (ev.kind === 'step_start') {
+                        appG.__klyroAppStatus?.({ step: ev.step });
+                    }
+                    else if (ev.kind === 'text_delta') {
+                        textBuf += ev.text;
+                        appG.__klyroAppAppend?.({ id: `text-${ev.kind}-${Date.now()}-${Math.random()}`, kind: 'text', text: ev.text, role: 'assistant' });
+                    }
+                    else if (ev.kind === 'tool_call_start') {
+                        activeCallId = ev.id;
+                        activeCallName = ev.name;
+                        activeCallArgs = '';
+                    }
+                    else if (ev.kind === 'tool_call_delta') {
+                        activeCallArgs += ev.argsJson;
+                    }
+                    else if (ev.kind === 'tool_call_end') {
+                        appG.__klyroAppAppend?.({
+                            id: `tool-${ev.id}-${Date.now()}`,
+                            kind: 'tool',
+                            name: ev.name,
+                            id_call: ev.id,
+                            args: JSON.stringify(ev.input, null, 2),
+                            collapsed: true,
+                        });
+                        activeCallId = null;
+                        activeCallName = null;
+                        activeCallArgs = '';
+                    }
+                    else if (ev.kind === 'policy_decision') {
+                        appG.__klyroAppAppend?.({
+                            id: `pol-${ev.id}-${Date.now()}`,
+                            kind: 'policy',
+                            name: ev.name,
+                            action: ev.action,
+                            reason: ev.reason,
+                        });
+                    }
+                    else if (ev.kind === 'tool_result') {
+                        appG.__klyroAppAppend?.({
+                            id: `tres-${ev.id}-${Date.now()}`,
+                            kind: 'tool',
+                            name: ev.name,
+                            id_call: ev.id,
+                            args: '',
+                            result: typeof ev.output === 'string' ? ev.output : JSON.stringify(ev.output, null, 2),
+                            isError: ev.isError,
+                            latencyMs: ev.latencyMs,
+                            collapsed: true,
+                        });
+                    }
+                    else if (ev.kind === 'usage') {
+                        appG.__klyroAppStatus?.({ usageInput: ev.input, usageOutput: ev.output });
+                    }
+                    else if (ev.kind === 'aborted') {
+                        appG.__klyroAppStatus?.({ status: 'aborted' });
+                    }
+                },
+            }, { adapter, registry, policy, approval, systemPrompt: systemPromptFn });
+            appG.__klyroAppStatus?.({ status: 'complete' === result.status ? 'done' : 'error', repairs: result.repairs ?? 0 });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            appG.__klyroAppAppend?.({ id: `err-${Date.now()}`, kind: 'error', message });
+            appG.__klyroAppStatus?.({ status: 'error', errorMessage: message });
+        }
+    }
+    async function handleSlash(cmd) {
+        switch (cmd.kind) {
+            case 'quit':
+                app.unmount();
+                process.exit(0);
+                return;
+            case 'clear':
+                // Bypass via the app's setTranscript by re-rendering is awkward;
+                // for MVP, append a marker and rely on the user to scroll.
+                // A real implementation would expose a clear() method.
+                appG.__klyroAppAppend?.({ id: `sep-${Date.now()}`, kind: 'text', text: '--- cleared ---', role: 'assistant' });
+                return;
+            case 'help': {
+                const helpText = 'commands: /clear /compact /model <id> /diff /status /quit';
+                appG.__klyroAppAppend?.({ id: `help-${Date.now()}`, kind: 'text', text: helpText, role: 'assistant' });
+                return;
+            }
+            case 'status': {
+                if (lastStatus) {
+                    appG.__klyroAppAppend?.({
+                        id: `stat-${Date.now()}`,
+                        kind: 'text',
+                        text: JSON.stringify(lastStatus, null, 2),
+                        role: 'assistant',
+                    });
+                }
+                return;
+            }
+            case 'compact':
+            case 'diff':
+            case 'model':
+                appG.__klyroAppAppend?.({
+                    id: `stub-${Date.now()}`,
+                    kind: 'text',
+                    text: `/${cmd.kind} is a stub in this build. (${cmd.kind === 'model' ? `requested: ${cmd.model}` : 'persistence integration pending'})`,
+                    role: 'assistant',
+                });
+                return;
+            case 'unknown':
+                appG.__klyroAppAppend?.({
+                    id: `unk-${Date.now()}`,
+                    kind: 'error',
+                    message: `unknown command: ${cmd.raw} (try /help)`,
+                });
+                return;
+        }
+    }
+    return new Promise((resolve) => {
+        process.on('exit', () => resolve(0));
+    });
+}

package/dist/cli/run.d.ts

@@ -0,0 +1,67 @@
+/**
+ * `klyro run "<prompt>"` — one-shot autonomous task. Runs the agent loop
+ * to completion (or max_steps) and prints the final text. Non-interactive:
+ * policy denies `ask` decisions rather than prompting the user.
+ *
+ * Streams text deltas to stdout as they arrive so the user sees progress
+ * even on a long task. Tool calls and policy decisions go to stderr so
+ * they don't pollute the captured `finalText` if the user pipes.
+ */
+import type { Message } from '../agent/message.js';
+export interface RunCliOptions {
+    task: string;
+    cwd: string;
+    model: string;
+    maxSteps?: number;
+    maxTokens?: number;
+    temperature?: number;
+    systemPrompt?: (ctx: {
+        cwd: string;
+        telemetry?: string;
+    }) => string;
+    baseUrl?: string;
+    apiKey?: string;
+    timeoutMs?: number;
+    abortOnSigint?: boolean;
+    /** Inject a custom adapter (used by tests). If omitted, httpChatAdapter is used. */
+    adapter?: import('../agent/provider-adapter.js').ProviderAdapter;
+    /**
+     * Provider kind to use when no custom adapter is supplied. Default 'openai'.
+     * Set to 'anthropic' to use the Anthropic Messages API adapter; in that
+     * case `baseUrl` defaults to https://api.anthropic.com and the auth header
+     * is sent as `x-api-key` (or `Authorization: Bearer` if `authHeader: 'bearer'`).
+     */
+    provider?: 'openai' | 'anthropic';
+    /** When provider='anthropic', override the auth header. Default 'x-api-key'. */
+    authHeader?: 'x-api-key' | 'Authorization';
+    /**
+     * Output mode:
+     *   - 'human' (default): text deltas on stdout, tool/policy on stderr
+     *   - 'json': one JSON object per line per RuntimeEvent on stdout
+     *   - 'silent': no streaming output; only the final text printed at the end
+     */
+    output?: 'human' | 'json' | 'silent';
+    /**
+     * Dry-run: don't actually call the model. Print the request that would
+     * be made (system prompt + tool definitions + first user message) and
+     * exit 0. Useful for inspecting the prompt assembly and verifying wiring.
+     */
+    dryRun?: boolean;
+    /**
+     * Path to a JSON file containing a saved transcript to resume from.
+     * The file must have shape `{transcript: Message[]}` and optionally
+     * `task?: string`. If `task` is present, it's used as the new user
+     * turn; if absent, `opts.task` is appended.
+     */
+    resumePath?: string;
+}
+export declare function runOnce(opts: RunCliOptions): Promise<number>;
+/** Wrap a system-prompt fn to inject Level-6 context (project map etc.). */
+export declare function makeRunSystemPrompt(cwd: string, base: (ctx: {
+    cwd: string;
+    telemetry?: string;
+}) => string): Promise<(ctx: {
+    cwd: string;
+    telemetry?: string;
+}) => string>;
+export declare function loadTranscript(path: string): Message[];

package/dist/cli/run.js

@@ -0,0 +1,198 @@
+/**
+ * `klyro run "<prompt>"` — one-shot autonomous task. Runs the agent loop
+ * to completion (or max_steps) and prints the final text. Non-interactive:
+ * policy denies `ask` decisions rather than prompting the user.
+ *
+ * Streams text deltas to stdout as they arrive so the user sees progress
+ * even on a long task. Tool calls and policy decisions go to stderr so
+ * they don't pollute the captured `finalText` if the user pipes.
+ */
+import { stdout, stderr } from 'node:process';
+import { httpChatAdapter } from '../agent/provider-adapter.js';
+import { anthropicAdapter } from '../agent/anthropic-adapter.js';
+import { run } from '../agent/runtime.js';
+import { builtinRegistry } from '../tools/registry.js';
+import { builtinRules, DEFAULT_POLICY_CONFIG, PolicyEngine } from '../policy/engine.js';
+import { DenyAllApprovalPrompt } from '../policy/approval.js';
+import { buildLevel6Context } from '../context/level6.js';
+;
+import * as fs from 'node:fs';
+function readEnv(name, fallback) {
+    const v = process.env[name];
+    return v && v.length > 0 ? v : fallback;
+}
+export async function runOnce(opts) {
+    const output = opts.output ?? 'human';
+    if (opts.dryRun) {
+        return dryRunReport(opts);
+    }
+    let adapter = opts.adapter;
+    if (!adapter) {
+        const provider = opts.provider ?? 'openai';
+        const baseUrl = opts.baseUrl ?? readEnv('KLYRO_BASE_URL');
+        const apiKey = opts.apiKey ?? readEnv('KLYRO_API_KEY');
+        if (!apiKey) {
+            stderr.write('klyro: KLYRO_API_KEY is not set (or pass --api-key)\n');
+            return 2;
+        }
+        if (provider === 'anthropic') {
+            adapter = anthropicAdapter({
+                baseURL: baseUrl,
+                apiKey,
+                timeoutMs: opts.timeoutMs ?? 60_000,
+                authHeader: opts.authHeader,
+            });
+        }
+        else {
+            if (!baseUrl) {
+                stderr.write('klyro: KLYRO_BASE_URL is not set (or pass --base-url)\n');
+                return 2;
+            }
+            adapter = httpChatAdapter({ baseURL: baseUrl, apiKey, timeoutMs: opts.timeoutMs ?? 60_000 });
+        }
+    }
+    const registry = builtinRegistry();
+    const policy = new PolicyEngine(builtinRules(), DEFAULT_POLICY_CONFIG);
+    const systemPrompt = await makeRunSystemPrompt(opts.cwd, opts.systemPrompt ?? defaultRunSystemPrompt);
+    const ac = new AbortController();
+    if (opts.abortOnSigint !== false) {
+        process.on('SIGINT', () => {
+            stderr.write('\nklyro: SIGINT — aborting\n');
+            ac.abort();
+        });
+    }
+    const result = await run({
+        task: opts.task,
+        cwd: opts.cwd,
+        model: opts.model,
+        maxSteps: opts.maxSteps,
+        maxTokens: opts.maxTokens,
+        temperature: opts.temperature,
+        signal: ac.signal,
+        nonInteractive: true,
+        initialTranscript: opts.resumePath ? loadTranscript(opts.resumePath) : undefined,
+        onEvent: (ev) => {
+            if (output === 'json') {
+                stdout.write(JSON.stringify(ev) + '\n');
+                return;
+            }
+            if (output === 'silent') {
+                return;
+            }
+            // human mode
+            if (ev.kind === 'text_delta')
+                stdout.write(ev.text);
+            else if (ev.kind === 'tool_call_start') {
+                stderr.write(`\n[tool] ${ev.name} {\n`);
+            }
+            else if (ev.kind === 'tool_call_end') {
+                stderr.write(`\n}\n`);
+            }
+            else if (ev.kind === 'tool_result') {
+                const summary = typeof ev.output === 'string' ? ev.output.slice(0, 200) : JSON.stringify(ev.output).slice(0, 200);
+                stderr.write(`  -> ${ev.isError ? 'ERR ' : 'ok  '}(${ev.latencyMs}ms) ${summary}\n`);
+            }
+            else if (ev.kind === 'policy_decision' && ev.action !== 'allow') {
+                stderr.write(`  policy: ${ev.action}${ev.reason ? ` — ${ev.reason}` : ''}\n`);
+            }
+            else if (ev.kind === 'step_start') {
+                stderr.write(`\n[step ${ev.step}]\n`);
+            }
+        },
+    }, { adapter, registry, policy, approval: new DenyAllApprovalPrompt(), systemPrompt });
+    if (output !== 'json')
+        stdout.write('\n');
+    if (result.status === 'max_steps') {
+        if (output === 'json')
+            stdout.write(JSON.stringify({ kind: 'final', status: result.status, steps: result.steps }) + '\n');
+        else
+            stderr.write(`klyro: hit max steps (${result.steps}); consider raising --max-steps\n`);
+        return 3;
+    }
+    if (result.status === 'aborted') {
+        return 130;
+    }
+    if (result.status === 'no_final') {
+        if (output !== 'json')
+            stderr.write('klyro: provider error — no final answer\n');
+        return 4;
+    }
+    if (output === 'json')
+        stdout.write(JSON.stringify({ kind: 'final', status: 'ok', text: result.finalText }) + '\n');
+    return 0;
+}
+function dryRunReport(opts) {
+    const systemPrompt = (opts.systemPrompt ?? defaultRunSystemPrompt)({ cwd: opts.cwd });
+    const registry = builtinRegistry();
+    const rules = builtinRules();
+    const report = {
+        kind: 'dry_run',
+        cwd: opts.cwd,
+        model: opts.model,
+        maxSteps: opts.maxSteps,
+        maxTokens: opts.maxTokens,
+        temperature: opts.temperature,
+        systemPrompt,
+        task: opts.task,
+        toolCount: registry.list().length,
+        toolNames: registry.list().map((t) => t.name),
+        policyRules: rules.map((r) => r.name),
+    };
+    stdout.write(JSON.stringify(report, null, 2) + '\n');
+    return 0;
+}
+function defaultRunSystemPrompt(_ctx) {
+    const base = [
+        'You are Klyro running in one-shot mode. The user has given you a single task.',
+        'Solve it by calling tools as needed. When done, produce a short final text answer.',
+        'Do not invent file paths. Do not call tools outside the working directory.',
+    ].join(' ');
+    return _ctx.telemetry ? base + '\n\n' + _ctx.telemetry : base;
+}
+/** Wrap a system-prompt fn to inject Level-6 context (project map etc.). */
+export async function makeRunSystemPrompt(cwd, base) {
+    const ctxBlock = await buildLevel6Context({ cwd });
+    const prefix = ctxBlock.formatted ? `\n\n<context>\n${ctxBlock.formatted}\n</context>` : '';
+    return (ctx) => {
+        const t = ctx.telemetry ? '\n\n' + ctx.telemetry : '';
+        return base(ctx) + prefix + t;
+    };
+}
+export function loadTranscript(path) {
+    let raw;
+    try {
+        raw = fs.readFileSync(path, 'utf8');
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`cannot read transcript file '${path}': ${msg}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`transcript file '${path}' is not valid JSON: ${msg}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`transcript file '${path}' must be a JSON object with a 'transcript' field`);
+    }
+    const obj = parsed;
+    if (!Array.isArray(obj.transcript)) {
+        throw new Error(`transcript file '${path}' is missing required field 'transcript' (array of Message)`);
+    }
+    // Light shape check — full validation would re-implement message.ts. We
+    // trust the shape from a previous run; failures at runtime will surface
+    // clearly from the provider adapter.
+    for (const m of obj.transcript) {
+        if (typeof m !== 'object' || m === null) {
+            throw new Error(`transcript file '${path}' has non-object message: ${JSON.stringify(m).slice(0, 80)}`);
+        }
+        const mm = m;
+        if (typeof mm.role !== 'string' || !Array.isArray(mm.content)) {
+            throw new Error(`transcript file '${path}' has malformed message (need role:string + content:[]): ${JSON.stringify(m).slice(0, 80)}`);
+        }
+    }
+    return obj.transcript;
+}

package/dist/cli/slash/parser.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Slash command parser — turns "/model foo" into a typed Command.
+ *
+ * Commands supported in MVP:
+ *   /clear             — clear the visible transcript (not the agent's)
+ *   /compact           — ask the agent to compact its own context
+ *   /model <id>        — switch the active model mid-session
+ *   /diff              — show working-tree diff (git diff)
+ *   /status            — show session status (model, steps, usage)
+ *   /quit              — exit the REPL
+ *   /help              — list available commands
+ *
+ * Anything not starting with "/" is a regular prompt and yields
+ * { kind: 'prompt', text }.
+ */
+export type SlashCommand = {
+    kind: 'clear';
+} | {
+    kind: 'compact';
+} | {
+    kind: 'model';
+    model: string;
+} | {
+    kind: 'diff';
+} | {
+    kind: 'status';
+} | {
+    kind: 'quit';
+} | {
+    kind: 'help';
+} | {
+    kind: 'prompt';
+    text: string;
+} | {
+    kind: 'unknown';
+    raw: string;
+};
+export declare function parse(input: string): SlashCommand;
+export declare function listCommands(): string[];

package/dist/cli/slash/parser.js

@@ -0,0 +1,47 @@
+/**
+ * Slash command parser — turns "/model foo" into a typed Command.
+ *
+ * Commands supported in MVP:
+ *   /clear             — clear the visible transcript (not the agent's)
+ *   /compact           — ask the agent to compact its own context
+ *   /model <id>        — switch the active model mid-session
+ *   /diff              — show working-tree diff (git diff)
+ *   /status            — show session status (model, steps, usage)
+ *   /quit              — exit the REPL
+ *   /help              — list available commands
+ *
+ * Anything not starting with "/" is a regular prompt and yields
+ * { kind: 'prompt', text }.
+ */
+const KNOWN = ['clear', 'compact', 'model', 'diff', 'status', 'quit', 'help'];
+export function parse(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith('/')) {
+        return { kind: 'prompt', text: trimmed };
+    }
+    const space = trimmed.indexOf(' ');
+    const name = (space === -1 ? trimmed.slice(1) : trimmed.slice(1, space)).toLowerCase();
+    const rest = space === -1 ? '' : trimmed.slice(space + 1).trim();
+    switch (name) {
+        case 'clear': return { kind: 'clear' };
+        case 'compact': return { kind: 'compact' };
+        case 'diff': return { kind: 'diff' };
+        case 'status': return { kind: 'status' };
+        case 'quit':
+        case 'exit':
+        case 'q': return { kind: 'quit' };
+        case 'help':
+        case '?': return { kind: 'help' };
+        case 'model':
+        case 'm': {
+            if (!rest)
+                return { kind: 'unknown', raw: trimmed };
+            return { kind: 'model', model: rest };
+        }
+        default:
+            return { kind: 'unknown', raw: trimmed };
+    }
+}
+export function listCommands() {
+    return [...KNOWN];
+}

package/dist/context/level6.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Level-6 context: project map + repo map + recent files + dependencies.
+ *
+ * Computed once per run, formatted compactly, and prepended to the system
+ * prompt. Each sub-block is independently optional — if a sub-step errors
+ * (e.g. unreadable package.json), we omit that block rather than failing
+ * the whole context load.
+ *
+ * Token budget: we cap each sub-block so the total added context is bounded
+ * (≤ ~6 KB). The exact budget is exposed via Level6Options.
+ *
+ * Static counterpart to Level-7 (`./level7.ts`), which injects a *live*
+ * runtime-telemetry snapshot (step count, recent tool calls, errors) into
+ * every model call. Together they give the model a static picture of the
+ * project (L6) and a live picture of its own run (L7).
+ */
+export interface Level6Options {
+    cwd: string;
+    /** Cap on the formatted total (in characters). */
+    maxTotalChars?: number;
+    /** Skip the project map block. */
+    skipProjectMap?: boolean;
+    /** Skip the repo map block. */
+    skipRepoMap?: boolean;
+    /** Skip the recent files block. */
+    skipRecentFiles?: boolean;
+    /** Skip the dependencies block. */
+    skipDeps?: boolean;
+    /** Hours window for "recent". */
+    recentHours?: number;
+}
+export interface Level6Context {
+    formatted: string;
+    hasProjectMap: boolean;
+    hasRepoMap: boolean;
+    hasRecentFiles: boolean;
+    hasDeps: boolean;
+    /** Number of bytes saved to disk cache (0 if cache disabled). */
+    cacheBytes?: number;
+}
+/** Build a Level-6 context block for the given working directory. */
+export declare function buildLevel6Context(opts: Level6Options): Promise<Level6Context>;
+/** Persist the Level-6 context to a JSON cache under .klyro/. */
+export declare function writeLevel6Cache(cwd: string, ctx: Level6Context): Promise<string | null>;
+export declare function readLevel6Cache(cwd: string): Promise<Level6Context | null>;