klyro 0.1.61 → 0.1.63

package/dist/policy/approval.js

@@ -7,6 +7,7 @@
  */
 import * as readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
+import { patternForCall } from './patterns.js';
 /** Default prompt backed by readline on stdin/stdout. */
 export class StdinApprovalPrompt {
     async ask(req) {
@@ -34,21 +35,48 @@ export class DenyAllApprovalPrompt {
     }
 }
 /**
- * In-memory allowlist: tracks "always" choices by command prefix so a
- * single prompt per command covers repeat invocations in the same session.
+ * Pattern approval cache — ask-once-per-pattern (Claude-Code-like).
+ *
+ * Wraps any inner prompt (TUI modal, stdin). The first `ask` for a pattern
+ * delegates to the user; `always` records the pattern for the session,
+ * `always-persist` additionally calls `onPersist` (the CLI wires this to
+ * append the pattern to ~/.klyro/settings.json and the live engine).
+ * Re-prompts never happen for a recorded pattern within the session.
+ *
+ * The pattern comes from `req.pattern` (pre-derived by the runtime via
+ * `patternForCall`) or is derived from `req.input` here as a fallback.
  */
-export class InMemoryAllowlist {
+export class PatternApprovalCache {
     inner;
-    allow = new Set();
-    constructor(inner = new DenyAllApprovalPrompt()) {
+    opts;
+    session = new Set();
+    constructor(inner = new DenyAllApprovalPrompt(), opts = {}) {
         this.inner = inner;
+        this.opts = opts;
     }
     async ask(req) {
-        if (this.allow.has(req.summary))
+        const key = req.pattern ?? patternFromRequest(req);
+        if (key && this.session.has(key))
             return 'allow';
         const choice = await this.inner.ask(req);
-        if (choice === 'always')
-            this.allow.add(req.summary);
+        if ((choice === 'always' || choice === 'always-persist') && key) {
+            this.session.add(key);
+        }
+        if (choice === 'always-persist' && key) {
+            // Best-effort: the current call is already approved via the session
+            // set above — a persist failure must not retro-deny it.
+            try {
+                await this.opts.onPersist?.(key);
+            }
+            catch {
+                /* ignore */
+            }
+        }
         return choice;
     }
 }
+function patternFromRequest(req) {
+    if (!req.input)
+        return undefined;
+    return patternForCall(req.toolName, req.input);
+}

package/dist/policy/engine.d.ts

@@ -67,6 +67,19 @@ export declare class PolicyEngine {
         nonInteractive: boolean;
     }): Promise<Decision>;
     private evaluateGlobRules;
+    /**
+     * Session rule management — appends a glob rule (`tool(glob)` grammar)
+     * if not already present. Used for persisted "always allow" patterns
+     * (loaded at startup) and live additions (approval `always→settings`).
+     */
+    addAllow(rule: string): void;
+    addDeny(rule: string): void;
+    addAsk(rule: string): void;
+    applyRules(rules: {
+        allow?: string[];
+        deny?: string[];
+        ask?: string[];
+    }): void;
 }
 /** Builtin set of rules. Order matters: first match wins. */
 export declare function builtinRules(): PolicyRule[];

package/dist/policy/engine.js

@@ -116,6 +116,34 @@ export class PolicyEngine {
         // Precedence: deny → allow → ask
         return check(this.config.deny, 'deny') ?? check(this.config.allow, 'allow') ?? check(this.config.ask, 'ask') ?? null;
     }
+    /**
+     * Session rule management — appends a glob rule (`tool(glob)` grammar)
+     * if not already present. Used for persisted "always allow" patterns
+     * (loaded at startup) and live additions (approval `always→settings`).
+     */
+    addAllow(rule) {
+        const list = (this.config.allow ??= []);
+        if (!list.includes(rule))
+            list.push(rule);
+    }
+    addDeny(rule) {
+        const list = (this.config.deny ??= []);
+        if (!list.includes(rule))
+            list.push(rule);
+    }
+    addAsk(rule) {
+        const list = (this.config.ask ??= []);
+        if (!list.includes(rule))
+            list.push(rule);
+    }
+    applyRules(rules) {
+        for (const r of rules.allow ?? [])
+            this.addAllow(r);
+        for (const r of rules.deny ?? [])
+            this.addDeny(r);
+        for (const r of rules.ask ?? [])
+            this.addAsk(r);
+    }
 }
 /** Builtin set of rules. Order matters: first match wins. */
 export function builtinRules() {

package/dist/policy/patterns.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Approval patterns — the unit of "always allow this pattern".
+ *
+ * A pattern uses the same `tool(glob)` grammar the policy engine matches
+ * (`matchesGlobRule` in engine.ts), e.g. `shell_exec(npm *)`,
+ * `write_file(src/index.ts)`. Derivation is deterministic: the same call
+ * shape always yields the same pattern, so session caching can key on exact
+ * pattern equality and persisted patterns re-match across sessions.
+ *
+ * Scoping (Claude-Code-like):
+ *   - shell_exec / run_verify → first command word + ` *`
+ *     (`npm test` and `npm run build` share `shell_exec(npm *)`)
+ *   - file tools with a path → the exact path (safest: no wildcards)
+ *   - everything else → the bare tool name (whole-tool session allow)
+ */
+export declare function patternForCall(name: string, input: Record<string, unknown>): string;

package/dist/policy/patterns.js

@@ -0,0 +1,26 @@
+/**
+ * Approval patterns — the unit of "always allow this pattern".
+ *
+ * A pattern uses the same `tool(glob)` grammar the policy engine matches
+ * (`matchesGlobRule` in engine.ts), e.g. `shell_exec(npm *)`,
+ * `write_file(src/index.ts)`. Derivation is deterministic: the same call
+ * shape always yields the same pattern, so session caching can key on exact
+ * pattern equality and persisted patterns re-match across sessions.
+ *
+ * Scoping (Claude-Code-like):
+ *   - shell_exec / run_verify → first command word + ` *`
+ *     (`npm test` and `npm run build` share `shell_exec(npm *)`)
+ *   - file tools with a path → the exact path (safest: no wildcards)
+ *   - everything else → the bare tool name (whole-tool session allow)
+ */
+export function patternForCall(name, input) {
+    if ((name === 'shell_exec' || name === 'run_verify') && typeof input.command === 'string') {
+        const first = input.command.trim().split(/\s+/, 1)[0] ?? '';
+        if (first)
+            return `${name}(${first} *)`;
+    }
+    if (typeof input.path === 'string' && input.path.length > 0) {
+        return `${name}(${input.path})`;
+    }
+    return name;
+}

package/dist/tui/app.js

@@ -13,6 +13,7 @@ import { tokens, g } from './tokens.js';
 import { initialScroll, scrollReducer, resolveTopRow, maxTopFor, } from './scroll-model.js';
 import { buildIndex, itemAtRow, MeasureCache } from './measure.js';
 import { renderMarkdownLines } from './markdown.js';
+import { readVersion } from '../version.js';
 import { getTranscriptCommand, } from './transcript-commands.js';
 import { estimateCost, getModelInfo } from '../providers/model-info.js';
 let _id = 0;
@@ -674,7 +675,8 @@ export function App(props) {
             setHistIdx(null);
         }
     });
-    const ver = props.version ?? '0.1.27';
+    // Single source of truth: package.json via version.ts — never hardcoded.
+    const ver = props.version ?? readVersion();
     const rule = g('rule').repeat(Math.max(10, width - 2));
     // Single cost/context source: model-aware registry rates + window.
     const cost = estimateCost(status.model, status.usageInput, status.usageOutput);

package/dist/tui/app.test.js

@@ -565,6 +565,16 @@ describe('App', () => {
         const top = await waitForMatch(lastFrame, /⇅ 0\/\d+/);
         expect(top).toMatch(/MSG-00-tag/);
     });
+    it('header shows the passed version, defaulting to package.json (never stale)', async () => {
+        const { readVersion } = await import('../version.js');
+        const { lastFrame: f1 } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { }, version: "9.9.9-test" }));
+        await new Promise((r) => setTimeout(r, 50));
+        expect(f1() ?? '').toContain('9.9.9-test');
+        const { lastFrame: f2 } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { } }));
+        await new Promise((r) => setTimeout(r, 50));
+        expect(f2() ?? '').toContain(readVersion());
+        expect(f2() ?? '').not.toContain('0.1.27');
+    });
     it('Shift+Up / Shift+Down scroll by one line', async () => {
         const { stdin, lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { }, isFullscreen: true, initialTranscript: makeInitialTranscript(25) }));
         await new Promise((r) => setTimeout(r, 50));

package/dist/tui/approval.d.ts

@@ -13,7 +13,7 @@
  *      a Promise.
  *   3. The App polls getPending() on every render to show a modal.
  *   4. The App's useInput handler sees a pending prompt and routes
- *      y/n/a to the resolver.
+ *      y/a/A/n to the resolver (A = always-persist to settings).
  *
  * Non-TTY mode (no Ink mounted) keeps using StdinApprovalPrompt; this
  * module is only used when the TUI is active.

package/dist/tui/approval.js

@@ -14,7 +14,7 @@ import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
  *      a Promise.
  *   3. The App polls getPending() on every render to show a modal.
  *   4. The App's useInput handler sees a pending prompt and routes
- *      y/n/a to the resolver.
+ *      y/a/A/n to the resolver (A = always-persist to settings).
  *
  * Non-TTY mode (no Ink mounted) keeps using StdinApprovalPrompt; this
  * module is only used when the TUI is active.
@@ -85,7 +85,7 @@ export function ApprovalModal({ bridge }) {
             return;
         }
         if (c === 'A') {
-            bridge.resolve('always');
+            bridge.resolve('always-persist');
             return;
         }
         if (c === 'd' || c === 'n') {

package/dist/version.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Single source of truth for the Klyro version (read from package.json).
+ *
+ * Every surface — `klyro --version`, the TUI header, `/version` — reads
+ * through here, so a version bump in package.json shows up everywhere with
+ * no hardcoded fallbacks rotting behind.
+ */
+export declare function readVersion(): string;

package/dist/version.js

@@ -0,0 +1,47 @@
+/**
+ * Single source of truth for the Klyro version (read from package.json).
+ *
+ * Every surface — `klyro --version`, the TUI header, `/version` — reads
+ * through here, so a version bump in package.json shows up everywhere with
+ * no hardcoded fallbacks rotting behind.
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+export function readVersion() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        resolve(here, '..', 'package.json'),
+        resolve(here, '../..', 'package.json'),
+        resolve(here, '../../package.json'),
+    ];
+    for (const pkgPath of candidates) {
+        try {
+            const raw = readFileSync(pkgPath, 'utf8');
+            const pkg = JSON.parse(raw);
+            if (typeof pkg.version === 'string' && pkg.version.length > 0)
+                return pkg.version;
+        }
+        catch (err) {
+            const e = err;
+            // Only ignore missing file; surface JSON parse errors
+            if (e.code === 'ENOENT')
+                continue;
+            // Malformed JSON — warn but don't crash version output
+            process.stderr.write(`klyro: warning: malformed ${pkgPath}: ${e.message}\n`);
+            continue;
+        }
+    }
+    // Fallback: try require-style resolution
+    try {
+        const pkgPath = resolve(process.cwd(), 'package.json');
+        const raw = readFileSync(pkgPath, 'utf8');
+        const pkg = JSON.parse(raw);
+        if (pkg.name === 'klyro' && typeof pkg.version === 'string')
+            return pkg.version;
+    }
+    catch {
+        // ignore
+    }
+    return '0.0.0';
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "klyro",
-  "version": "0.1.61",
-  "description": "Klyro \u2014 autonomous coding harness CLI that streams from any OpenAI-compatible or Anthropic LLM endpoint.",
+  "version": "0.1.63",
+  "description": "Klyro — autonomous coding harness CLI that streams from any OpenAI-compatible or Anthropic LLM endpoint.",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",