klyro 1.0.5 → 1.0.6

package/dist/cli/config.d.ts

@@ -7,8 +7,8 @@ import { z } from 'zod';
 export declare const ConfigSchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodString>;
     provider: z.ZodOptional<z.ZodEnum<{
-        openai: "openai";
         anthropic: "anthropic";
+        openai: "openai";
     }>>;
     baseUrl: z.ZodOptional<z.ZodString>;
     apiKey: z.ZodOptional<z.ZodString>;
@@ -20,8 +20,8 @@ export declare const ConfigSchema: z.ZodObject<{
     providers: z.ZodOptional<z.ZodObject<{
         failover: z.ZodOptional<z.ZodArray<z.ZodObject<{
             provider: z.ZodEnum<{
-                openai: "openai";
                 anthropic: "anthropic";
+                openai: "openai";
             }>;
             baseURL: z.ZodOptional<z.ZodString>;
             apiKey: z.ZodOptional<z.ZodString>;
@@ -32,8 +32,8 @@ export declare const ConfigSchema: z.ZodObject<{
 export type KlyroConfig = z.infer<typeof ConfigSchema>;
 export declare const FailoverEntrySchema: z.ZodObject<{
     provider: z.ZodEnum<{
-        openai: "openai";
         anthropic: "anthropic";
+        openai: "openai";
     }>;
     baseURL: z.ZodOptional<z.ZodString>;
     apiKey: z.ZodOptional<z.ZodString>;
@@ -43,8 +43,8 @@ export type FailoverEntry = z.infer<typeof FailoverEntrySchema>;
 export declare const FailoverConfigSchema: z.ZodObject<{
     failover: z.ZodOptional<z.ZodArray<z.ZodObject<{
         provider: z.ZodEnum<{
-            openai: "openai";
             anthropic: "anthropic";
+            openai: "openai";
         }>;
         baseURL: z.ZodOptional<z.ZodString>;
         apiKey: z.ZodOptional<z.ZodString>;

package/dist/cli/eval.d.ts

@@ -54,6 +54,10 @@ export interface EvalScenario {
     };
     /** Adapter events to script, as [eventKind, ...args] tuples. */
     scripted_events?: Array<Array<unknown[]>>;
+    /** Semantic rubric graded by a model judge (needs --judge-model). */
+    judge?: {
+        rubric: string[];
+    };
     expect?: {
         status?: RunResult['status'];
         textContains?: string;
@@ -70,6 +74,11 @@ export interface EvalResult {
     toolCalls: number;
     text: string;
     durationMs: number;
+    judge?: {
+        pass: boolean;
+        notes: string;
+        skipped: boolean;
+    };
 }
 export interface RunEvalOptions {
     inputPath: string;
@@ -79,7 +88,12 @@ export interface RunEvalOptions {
     runs?: number;
     parallel?: number;
     model?: string;
+    /** Live model id for grading `judge.rubric` (env endpoint + key required). */
+    judgeModel?: string;
 }
 export declare function runEval(opts: RunEvalOptions): Promise<number>;
 export declare function scriptedAdapterFromSpec(spec: Array<Array<unknown[]>> | undefined): ProviderAdapter;
-export declare function runScenario(sc: EvalScenario): Promise<EvalResult>;
+export declare function runScenario(sc: EvalScenario, judgeOpts?: {
+    adapter: ProviderAdapter;
+    model: string;
+}): Promise<EvalResult>;

package/dist/cli/eval.js

@@ -131,10 +131,23 @@ export async function runEval(opts) {
         stderr.write('klyro eval: no scenarios in input\n');
         return 2;
     }
+    // Live judge adapter for `judge.rubric` (env endpoint + key; mock otherwise).
+    let judgeAdapter;
+    if (opts.judgeModel) {
+        const { httpChatAdapter } = await import('../agent/provider-adapter.js');
+        const { getStoredKey } = await import('./auth.js');
+        const baseUrl = process.env.KLYRO_BASE_URL;
+        const apiKey = process.env.KLYRO_API_KEY ?? getStoredKey('openai') ?? getStoredKey('anthropic');
+        if (!baseUrl || !apiKey) {
+            stderr.write('klyro eval: --judge-model needs KLYRO_BASE_URL and KLYRO_API_KEY (or a stored key)\n');
+            return 2;
+        }
+        judgeAdapter = httpChatAdapter({ baseURL: baseUrl, apiKey });
+    }
     const results = [];
     for (const sc of scenarios) {
         const start = Date.now();
-        const r = await runScenario(sc);
+        const r = await runScenario(sc, judgeAdapter && opts.judgeModel ? { adapter: judgeAdapter, model: opts.judgeModel } : undefined);
         r.durationMs = Date.now() - start;
         results.push(r);
         if (opts.output === 'json') {
@@ -223,7 +236,7 @@ function tupleToEvent(tuple) {
             throw new Error(`scriptedAdapterFromSpec: unknown event kind: ${kind}`);
     }
 }
-export async function runScenario(sc) {
+export async function runScenario(sc, judgeOpts) {
     const failures = [];
     const model = sc.model ?? 'mock';
     const adapter = scriptedAdapterFromSpec(sc.scripted_events);
@@ -265,6 +278,24 @@ export async function runScenario(sc) {
     if (exp.toolCallsAtMost !== undefined && result.toolCalls > exp.toolCallsAtMost) {
         failures.push(`toolCalls: expected <= ${exp.toolCallsAtMost}, got ${result.toolCalls}`);
     }
+    // Model-graded semantic check (opt-in: needs a live judge adapter).
+    let judge;
+    if (sc.judge && sc.judge.rubric.length > 0) {
+        if (judgeOpts) {
+            const { runJudge } = await import('../eval/judge.js');
+            const v = await runJudge(judgeOpts.adapter, judgeOpts.model, {
+                task: sc.task,
+                finalText: result.finalText,
+                toolCalls: result.toolCalls,
+            }, sc.judge.rubric);
+            judge = { pass: v.pass, notes: v.notes, skipped: v.skipped };
+            if (!v.pass)
+                failures.push(`judge: ${v.notes || 'rubric unmet'}`);
+        }
+        else {
+            judge = { pass: true, notes: 'no judge adapter — skipped', skipped: true };
+        }
+    }
     return {
         name: sc.name,
         passed: failures.length === 0,
@@ -274,5 +305,6 @@ export async function runScenario(sc) {
         toolCalls: result.toolCalls,
         text: result.finalText,
         durationMs: 0,
+        ...(judge ? { judge } : {}),
     };
 }

package/dist/cli/hooks.d.ts

@@ -1,26 +1,46 @@
 /**
- * Hooks engine (10.2) — preToolUse / postToolUse shell hooks.
+ * Hooks engine (10.2, v2) — lifecycle + tool shell hooks.
+ *
+ * Events: `preToolUse` / `postToolUse` (per tool call), `sessionStart`
+ * (once per run, may abort it), `sessionEnd` (once per run, best-effort),
+ * `stop` (after each agent step).
  *
  * Config files:
  *   - project: `<cwd>/.klyro/hooks.json`
  *   - global:  `~/.klyro/hooks.json` (merged; project wins on name clash)
  *
- * Schema: `{ hooks: Array<{ name, event, command, timeoutMs? }> }`.
+ * Schema: `{ hooks: Array<{ name, event, command, matcher?, timeoutMs? }> }`.
+ * `matcher` is a regex tested against the tool name — lifecycle events
+ * (`sessionStart`/`sessionEnd`/`stop`) always match; tool events without a
+ * matcher match every tool.
  *
  * `loadHooks` never throws — a missing file is `[]`, an invalid file is
  * `[]` plus a one-time stderr warning per path. `runHook` spawns the
  * command with `shell: true` (commands are strings, must work on win +
- * posix), a default 30s timeout, a filtered env, plus `KLYRO_TOOL_NAME`
- * and `KLYRO_TOOL_INPUT_JSON` for the hook's inspection.
+ * posix), a default 30s timeout, a filtered env, `KLYRO_TOOL_NAME` /
+ * `KLYRO_TOOL_INPUT_JSON` for inspection, AND the full JSON payload on
+ * stdin (`{ event, tool, input, sessionId, ... }`).
  */
 import { z } from 'zod';
+export declare const HookEventSchema: z.ZodEnum<{
+    stop: "stop";
+    preToolUse: "preToolUse";
+    postToolUse: "postToolUse";
+    sessionStart: "sessionStart";
+    sessionEnd: "sessionEnd";
+}>;
+export type HookEvent = z.infer<typeof HookEventSchema>;
 export declare const HookSchema: z.ZodObject<{
     name: z.ZodString;
     event: z.ZodEnum<{
+        stop: "stop";
         preToolUse: "preToolUse";
         postToolUse: "postToolUse";
+        sessionStart: "sessionStart";
+        sessionEnd: "sessionEnd";
     }>;
     command: z.ZodString;
+    matcher: z.ZodOptional<z.ZodString>;
     timeoutMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type Hook = z.infer<typeof HookSchema>;
@@ -40,8 +60,37 @@ export interface HookContext {
     toolName: string;
     input: unknown;
 }
+/** Lifecycle payload delivered on stdin (and merged into env where small). */
+export interface HookPayload {
+    event: HookEvent;
+    tool?: string;
+    input?: unknown;
+    sessionId?: string;
+    cwd?: string;
+    status?: string;
+    step?: number;
+}
+/**
+ * Select hooks for an event. Tool events honor `matcher` (regex against the
+ * tool name; invalid regex never matches); lifecycle events always match.
+ * Exported pure for unit tests.
+ */
+export declare function hooksForEvent(hooks: Hook[], event: HookEvent, toolName?: string): Hook[];
 /**
  * Run one hook. Resolves (never rejects) with the exit code + sliced
  * output. `ok` is true only when the process exited 0.
+ *
+ * `stdinJson` (when given) is written to the child's stdin as JSON —
+ * the primary contract (mirrors CC's stdin-JSON hooks); the env vars are
+ * kept as a convenience for shell one-liners.
+ */
+export declare function runHook(hook: Hook, ctx: HookContext, stdinJson?: unknown): Promise<HookResult>;
+/**
+ * Run all `sessionEnd` hooks for a finished run (best-effort, sequential).
+ * Returns hook outputs for logging. Never throws.
  */
-export declare function runHook(hook: Hook, ctx: HookContext): Promise<HookResult>;
+export declare function runSessionEndHooks(cwd: string, sessionId: string | undefined, status: string): Promise<Array<{
+    name: string;
+    ok: boolean;
+    output: string;
+}>>;

package/dist/cli/hooks.js

@@ -1,27 +1,38 @@
 /**
- * Hooks engine (10.2) — preToolUse / postToolUse shell hooks.
+ * Hooks engine (10.2, v2) — lifecycle + tool shell hooks.
+ *
+ * Events: `preToolUse` / `postToolUse` (per tool call), `sessionStart`
+ * (once per run, may abort it), `sessionEnd` (once per run, best-effort),
+ * `stop` (after each agent step).
  *
  * Config files:
  *   - project: `<cwd>/.klyro/hooks.json`
  *   - global:  `~/.klyro/hooks.json` (merged; project wins on name clash)
  *
- * Schema: `{ hooks: Array<{ name, event, command, timeoutMs? }> }`.
+ * Schema: `{ hooks: Array<{ name, event, command, matcher?, timeoutMs? }> }`.
+ * `matcher` is a regex tested against the tool name — lifecycle events
+ * (`sessionStart`/`sessionEnd`/`stop`) always match; tool events without a
+ * matcher match every tool.
  *
  * `loadHooks` never throws — a missing file is `[]`, an invalid file is
  * `[]` plus a one-time stderr warning per path. `runHook` spawns the
  * command with `shell: true` (commands are strings, must work on win +
- * posix), a default 30s timeout, a filtered env, plus `KLYRO_TOOL_NAME`
- * and `KLYRO_TOOL_INPUT_JSON` for the hook's inspection.
+ * posix), a default 30s timeout, a filtered env, `KLYRO_TOOL_NAME` /
+ * `KLYRO_TOOL_INPUT_JSON` for inspection, AND the full JSON payload on
+ * stdin (`{ event, tool, input, sessionId, ... }`).
  */
 import { spawn } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { z } from 'zod';
+export const HookEventSchema = z.enum(['preToolUse', 'postToolUse', 'sessionStart', 'sessionEnd', 'stop']);
 export const HookSchema = z.object({
     name: z.string().min(1),
-    event: z.enum(['preToolUse', 'postToolUse']),
+    event: HookEventSchema,
     command: z.string().min(1),
+    /** Optional regex matched against the tool name (tool events only). */
+    matcher: z.string().min(1).optional(),
     timeoutMs: z.number().int().positive().optional(),
 });
 const HooksFileSchema = z.object({
@@ -116,11 +127,36 @@ function hookEnv() {
     out.PATH = process.env.PATH;
     return out;
 }
+/**
+ * Select hooks for an event. Tool events honor `matcher` (regex against the
+ * tool name; invalid regex never matches); lifecycle events always match.
+ * Exported pure for unit tests.
+ */
+export function hooksForEvent(hooks, event, toolName) {
+    return hooks.filter((h) => {
+        if (h.event !== event)
+            return false;
+        if (h.matcher === undefined)
+            return true;
+        if (toolName === undefined)
+            return true; // lifecycle events have no tool
+        try {
+            return new RegExp(h.matcher).test(toolName);
+        }
+        catch {
+            return false;
+        }
+    });
+}
 /**
  * Run one hook. Resolves (never rejects) with the exit code + sliced
  * output. `ok` is true only when the process exited 0.
+ *
+ * `stdinJson` (when given) is written to the child's stdin as JSON —
+ * the primary contract (mirrors CC's stdin-JSON hooks); the env vars are
+ * kept as a convenience for shell one-liners.
  */
-export function runHook(hook, ctx) {
+export function runHook(hook, ctx, stdinJson) {
     const timeoutMs = hook.timeoutMs ?? DEFAULT_HOOK_TIMEOUT_MS;
     return new Promise((resolve) => {
         let env;
@@ -139,6 +175,13 @@ export function runHook(hook, ctx) {
         catch {
             env.KLYRO_TOOL_INPUT_JSON = '{}';
         }
+        let payload = '';
+        try {
+            payload = JSON.stringify(stdinJson ?? { event: 'preToolUse', tool: ctx.toolName, input: ctx.input ?? {} });
+        }
+        catch {
+            payload = '{}';
+        }
         let child;
         try {
             child = spawn(hook.command, {
@@ -147,6 +190,7 @@ export function runHook(hook, ctx) {
                 windowsHide: true,
                 timeout: timeoutMs,
                 env,
+                stdio: ['pipe', 'pipe', 'pipe'],
             });
         }
         catch (err) {
@@ -177,5 +221,40 @@ export function runHook(hook, ctx) {
                 stderr: stderr.slice(0, MAX_HOOK_OUTPUT_CHARS),
             });
         });
+        // Deliver the stdin JSON contract, then close so the child never hangs
+        // waiting for EOF. Write errors (EPIPE on early exit) are ignored —
+        // the exit code below is what matters.
+        try {
+            if (child.stdin) {
+                child.stdin.on('error', () => undefined);
+                child.stdin.write(payload);
+                child.stdin.end();
+            }
+        }
+        catch { /* ignore */ }
     });
 }
+/**
+ * Run all `sessionEnd` hooks for a finished run (best-effort, sequential).
+ * Returns hook outputs for logging. Never throws.
+ */
+export async function runSessionEndHooks(cwd, sessionId, status) {
+    const out = [];
+    let hooks;
+    try {
+        hooks = hooksForEvent(loadHooks(cwd), 'sessionEnd');
+    }
+    catch {
+        return out;
+    }
+    for (const h of hooks) {
+        try {
+            const r = await runHook(h, { toolName: '', input: {} }, { event: 'sessionEnd', sessionId, cwd, status });
+            out.push({ name: h.name, ok: r.ok, output: (r.stdout || r.stderr || '').slice(0, 2000) });
+        }
+        catch {
+            out.push({ name: h.name, ok: false, output: '' });
+        }
+    }
+    return out;
+}

package/dist/cli/init.d.ts

@@ -0,0 +1,6 @@
+export interface InitResult {
+    created: string[];
+    skipped: string[];
+}
+export declare function initProject(cwd: string): Promise<InitResult>;
+export declare function nextStepsText(): string;

package/dist/cli/init.js

@@ -0,0 +1,60 @@
+/**
+ * Project bootstrap shared by `klyro init` and the REPL `/init`:
+ * scan-seeded KLYRO.md (only when absent) + `.mcp.json` skeleton.
+ * Never overwrites user files; returns created vs skipped lists.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+function captureStdout() {
+    const orig = process.stdout.write.bind(process.stdout);
+    let out = '';
+    process.stdout.write = ((c) => {
+        out += String(c);
+        return true;
+    });
+    return {
+        release: () => {
+            process.stdout.write = orig;
+            return out;
+        },
+    };
+}
+export async function initProject(cwd) {
+    const created = [];
+    const skipped = [];
+    const klyroMd = path.join(cwd, 'KLYRO.md');
+    if (fs.existsSync(klyroMd)) {
+        skipped.push('KLYRO.md (exists)');
+    }
+    else {
+        const { runScan } = await import('./scan.js');
+        const cap = captureStdout();
+        try {
+            await runScan({ cwd, json: false });
+        }
+        finally {
+            // release even if scan throws — partial output still seeds the draft
+        }
+        const out = cap.release();
+        fs.writeFileSync(klyroMd, `# KLYRO.md\n\nProject: ${cwd}\n\n## Stack\n\n${out.slice(0, 2000)}\n\n## Conventions\n\n- Prefer smallest change that solves the task.\n- Run verification after edits.\n`, 'utf-8');
+        created.push('KLYRO.md');
+    }
+    const mcpJson = path.join(cwd, '.mcp.json');
+    if (fs.existsSync(mcpJson)) {
+        skipped.push('.mcp.json (exists)');
+    }
+    else {
+        fs.writeFileSync(mcpJson, JSON.stringify({ mcpServers: {} }, null, 2) + '\n', 'utf-8');
+        created.push('.mcp.json');
+    }
+    return { created, skipped };
+}
+export function nextStepsText() {
+    return [
+        'Next steps:',
+        '  klyro login            # store provider key once (or set KLYRO_BASE_URL/_API_KEY/_MODEL)',
+        '  klyro doctor           # verify toolchain, provider, sessions, sandbox',
+        '  klyro agents           # list subagents (add yours in .klyro/agents/*.md)',
+        '  klyro mcp add <n> <cmd># attach a tool server (or https:// URL for remote)',
+    ].join('\n');
+}