klyro 0.1.4 → 0.1.6

package/dist/cli/auth.js

@@ -0,0 +1,84 @@
+/**
+ * 2.2 — klyro login / logout / aliases
+ * Stores masked key → ~/.klyro/credentials.json 0600
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import * as readline from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+function credPath() {
+    const home = os.homedir() || process.cwd();
+    return path.join(home, '.klyro', 'credentials.json');
+}
+export async function runLogin() {
+    const rl = readline.createInterface({ input: stdin, output: stdout });
+    try {
+        const provider = (await rl.question('Provider (anthropic/openai) [openai]: ')) || 'openai';
+        const key = await rl.question('API key (input hidden, paste): ');
+        if (!key.trim()) {
+            process.stderr.write('No key provided\n');
+            return 2;
+        }
+        const creds = {};
+        try {
+            const raw = await fs.readFile(credPath(), 'utf-8');
+            Object.assign(creds, JSON.parse(raw));
+        }
+        catch { /* ignore */ }
+        creds[provider] = key.trim();
+        await fs.mkdir(path.dirname(credPath()), { recursive: true });
+        await fs.writeFile(credPath(), JSON.stringify(creds, null, 2), { mode: 0o600 });
+        try {
+            await fs.chmod(credPath(), 0o600);
+        }
+        catch { /* ignore on Windows */ }
+        process.stdout.write(`Saved ${provider} key to ${credPath()} (0600)\n`);
+        return 0;
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function runLogout(provider) {
+    try {
+        const raw = await fs.readFile(credPath(), 'utf-8');
+        const creds = JSON.parse(raw);
+        if (provider) {
+            delete creds[provider];
+            await fs.writeFile(credPath(), JSON.stringify(creds, null, 2), 'utf-8');
+            process.stdout.write(`Removed ${provider} key\n`);
+        }
+        else {
+            await fs.unlink(credPath());
+            process.stdout.write('Removed all credentials\n');
+        }
+        return 0;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`No credentials to remove: ${msg}\n`);
+        return 1;
+    }
+}
+export function getStoredKey(provider) {
+    try {
+        const raw = require('node:fs').readFileSync(credPath(), 'utf-8');
+        const creds = JSON.parse(raw);
+        return creds[provider];
+    }
+    catch {
+        return undefined;
+    }
+}
+// Model aliases 2.2
+export const MODEL_ALIASES = {
+    sonnet: 'claude-3-5-sonnet-20240620',
+    opus: 'claude-3-opus-20240229',
+    haiku: 'claude-3-haiku-20240307',
+    gpt: 'gpt-4o',
+    local: 'llama3.2',
+};
+export function resolveAlias(model) {
+    return MODEL_ALIASES[model] ?? model;
+}

package/dist/cli/completion.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 1.2 — klyro completion
+ * Generates shell completion scripts for bash/zsh/fish/powershell.
+ */
+export declare function getCompletionScript(shell: string): string | null;
+export declare function runCompletion(shell?: string): Promise<number>;

package/dist/cli/completion.js

@@ -0,0 +1,66 @@
+/**
+ * 1.2 — klyro completion
+ * Generates shell completion scripts for bash/zsh/fish/powershell.
+ */
+const COMMANDS = ['tui', 'run', 'chat', 'config', 'doctor', 'completion', 'update', 'eval', 'session', 'resume', 'help', 'version'];
+function bashScript() {
+    return `# klyro bash completion
+_klyro_complete() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local cmds="${COMMANDS.join(' ')}"
+  COMPREPLY=( $(compgen -W "$cmds" -- "$cur") )
+}
+complete -F _klyro_complete klyro
+complete -F _klyro_complete ky
+`;
+}
+function zshScript() {
+    return `#compdef klyro ky
+_klyro() {
+  local -a completions
+  completions=(${COMMANDS.map((c) => `'${c}'`).join(' ')})
+  _describe 'klyro commands' completions
+}
+compdef _klyro klyro ky
+`;
+}
+function fishScript() {
+    return `# klyro fish completion
+${COMMANDS.map((c) => `complete -c klyro -f -a ${c}`).join('\n')}
+complete -c ky -f -a "${COMMANDS.join(' ')}"
+`;
+}
+function powershellScript() {
+    return `# klyro powershell completion
+Register-ArgumentCompleter -Native -CommandName klyro,ky -ScriptBlock {
+  param($wordToComplete, $commandAst, $cursorPosition)
+  $cmds = @(${COMMANDS.map((c) => `'${c}'`).join(', ')})
+  $cmds | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+  }
+}
+`;
+}
+export function getCompletionScript(shell) {
+    switch (shell) {
+        case 'bash': return bashScript();
+        case 'zsh': return zshScript();
+        case 'fish': return fishScript();
+        case 'powershell':
+        case 'pwsh': return powershellScript();
+        default: return null;
+    }
+}
+export async function runCompletion(shell) {
+    if (!shell) {
+        process.stderr.write('Usage: klyro completion <bash|zsh|fish|powershell>\n');
+        return 2;
+    }
+    const script = getCompletionScript(shell);
+    if (!script) {
+        process.stderr.write(`Unknown shell: ${shell} (expected bash|zsh|fish|powershell)\n`);
+        return 2;
+    }
+    process.stdout.write(script);
+    return 0;
+}

package/dist/cli/config.d.ts

@@ -0,0 +1,44 @@
+/**
+ * LEVEL 1 — klyro config (1.3)
+ * Precedence: flags → env → .klyro/settings.local.json → .klyro/settings.json → ~/.klyro/settings.json → defaults
+ * JSONC-tolerant, Zod schema, exit 3 on invalid.
+ */
+import { z } from 'zod';
+export declare const ConfigSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodEnum<{
+        anthropic: "anthropic";
+        openai: "openai";
+    }>>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    baseURL: z.ZodOptional<z.ZodString>;
+    api_key: z.ZodOptional<z.ZodString>;
+    'model.default': z.ZodOptional<z.ZodString>;
+    'model.small': z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type KlyroConfig = z.infer<typeof ConfigSchema>;
+export declare function getConfigDir(): string;
+export declare function getConfigPath(): string;
+export declare function getConfigSearchPaths(cwd?: string): Array<{
+    path: string;
+    layer: string;
+    exists: boolean;
+}>;
+declare function stripJsonComments(text: string): string;
+declare function getByPath(obj: Record<string, unknown>, dotted: string): unknown;
+declare function setByPath(obj: Record<string, unknown>, dotted: string, value: unknown): void;
+declare function deleteByPath(obj: Record<string, unknown>, dotted: string): boolean;
+declare function parseValue(raw: string): unknown;
+export declare function loadConfig(): Promise<Record<string, unknown>>;
+export declare function loadMergedConfig(cwd?: string, flags?: Record<string, unknown>): Promise<Record<string, unknown>>;
+export declare function saveConfig(obj: Record<string, unknown>): Promise<void>;
+export declare function runConfig(args: string[]): Promise<number>;
+export declare const _helpers: {
+    getByPath: typeof getByPath;
+    setByPath: typeof setByPath;
+    deleteByPath: typeof deleteByPath;
+    parseValue: typeof parseValue;
+    stripJsonComments: typeof stripJsonComments;
+};
+export {};

package/dist/cli/config.js

@@ -0,0 +1,428 @@
+/**
+ * LEVEL 1 — klyro config (1.3)
+ * Precedence: flags → env → .klyro/settings.local.json → .klyro/settings.json → ~/.klyro/settings.json → defaults
+ * JSONC-tolerant, Zod schema, exit 3 on invalid.
+ */
+import * as fs from 'node:fs/promises';
+import * as fsSync from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { z } from 'zod';
+import { KlyroError } from '../shared/errors.js';
+// --- Zod schema (Appendix A shape, L1 keys active, passthrough for future) ---
+export const ConfigSchema = z
+    .object({
+    model: z.string().optional(),
+    provider: z.enum(['openai', 'anthropic']).optional(),
+    baseUrl: z.string().optional(),
+    apiKey: z.string().optional(),
+    baseURL: z.string().optional(),
+    api_key: z.string().optional(),
+    // Global flags persisted
+    'model.default': z.string().optional(),
+    'model.small': z.string().optional(),
+})
+    .passthrough();
+// --- Paths ---
+export function getConfigDir() {
+    if (process.env.KLYRO_CONFIG_DIR)
+        return process.env.KLYRO_CONFIG_DIR;
+    const home = os.homedir();
+    if (home)
+        return path.join(home, '.klyro');
+    return path.join(process.cwd(), '.klyro');
+}
+export function getConfigPath() {
+    if (process.env.KLYRO_CONFIG)
+        return process.env.KLYRO_CONFIG;
+    // New canonical path per spec
+    return path.join(getConfigDir(), 'settings.json');
+}
+function getLegacyConfigPath() {
+    if (process.env.KLYRO_CONFIG)
+        return process.env.KLYRO_CONFIG;
+    const home = os.homedir();
+    if (home)
+        return path.join(home, '.klyro', 'config.json');
+    return path.join(process.cwd(), '.klyro', 'config.json');
+}
+export function getConfigSearchPaths(cwd = process.cwd()) {
+    const homeSettings = path.join(getConfigDir(), 'settings.json');
+    const projSettings = path.join(cwd, '.klyro', 'settings.json');
+    const projLocal = path.join(cwd, '.klyro', 'settings.local.json');
+    const legacy = getLegacyConfigPath();
+    const paths = [
+        { path: homeSettings, layer: '~/.klyro/settings.json' },
+        { path: legacy, layer: '~/.klyro/config.json (legacy)' },
+        { path: projSettings, layer: '.klyro/settings.json' },
+        { path: projLocal, layer: '.klyro/settings.local.json' },
+    ];
+    return paths.map((p) => ({ ...p, exists: fsSync.existsSync(p.path) }));
+}
+// --- JSONC ---
+function stripJsonComments(text) {
+    let out = '';
+    let inString = false;
+    let escaped = false;
+    let inSingleLineComment = false;
+    let inMultiLineComment = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        const nxt = text[i + 1];
+        if (inSingleLineComment) {
+            if (ch === '\n') {
+                inSingleLineComment = false;
+                out += ch;
+            }
+            continue;
+        }
+        if (inMultiLineComment) {
+            if (ch === '*' && nxt === '/') {
+                inMultiLineComment = false;
+                i++;
+            }
+            continue;
+        }
+        if (inString) {
+            out += ch;
+            if (escaped)
+                escaped = false;
+            else if (ch === '\\')
+                escaped = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === '/' && nxt === '/') {
+            inSingleLineComment = true;
+            i++;
+            continue;
+        }
+        if (ch === '/' && nxt === '*') {
+            inMultiLineComment = true;
+            i++;
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+function parseJsonc(raw, filePath) {
+    const stripped = stripJsonComments(raw);
+    try {
+        const parsed = JSON.parse(stripped);
+        if (parsed == null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new KlyroError('CONFIG_INVALID', `config is not a JSON object: ${filePath}`, {
+                hint: 'Fix the file to be a JSON object, e.g. {"model":"gpt-4o-mini"}',
+                exitCode: 3,
+            });
+        }
+        return parsed;
+    }
+    catch (err) {
+        if (err instanceof KlyroError)
+            throw err;
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new KlyroError('CONFIG_INVALID', `invalid JSON in ${filePath}: ${msg}`, {
+            hint: `Check ${filePath} for trailing commas or comments — JSONC is allowed but must be valid`,
+            exitCode: 3,
+        });
+    }
+}
+function validateConfig(obj, filePath) {
+    const res = ConfigSchema.safeParse(obj);
+    if (!res.success) {
+        const issues = res.error.issues.map((iss) => `${iss.path.join('.')}: ${iss.message}`).join('; ');
+        throw new KlyroError('CONFIG_INVALID', `invalid config ${filePath}: ${issues}`, {
+            hint: 'Fix the key per expected type, e.g. "model": "gpt-4o-mini"',
+            exitCode: 3,
+        });
+    }
+    return res.data;
+}
+// --- Helpers for dotted paths (unchanged) ---
+function getByPath(obj, dotted) {
+    const parts = dotted.split('.');
+    let cur = obj;
+    for (const p of parts) {
+        if (cur == null || typeof cur !== 'object')
+            return undefined;
+        cur = cur[p];
+    }
+    return cur;
+}
+function setByPath(obj, dotted, value) {
+    const parts = dotted.split('.');
+    let cur = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const p = parts[i];
+        const nxt = cur[p];
+        if (nxt == null || typeof nxt !== 'object' || Array.isArray(nxt))
+            cur[p] = {};
+        cur = cur[p];
+    }
+    cur[parts[parts.length - 1]] = value;
+}
+function deleteByPath(obj, dotted) {
+    const parts = dotted.split('.');
+    let cur = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const p = parts[i];
+        const nxt = cur[p];
+        if (nxt == null || typeof nxt !== 'object')
+            return false;
+        cur = nxt;
+    }
+    const last = parts[parts.length - 1];
+    if (!(last in cur))
+        return false;
+    delete cur[last];
+    return true;
+}
+function parseValue(raw) {
+    const trimmed = raw.trim();
+    if (trimmed === '')
+        return '';
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return raw;
+    }
+}
+// --- Single-file load (backward compat) ---
+export async function loadConfig() {
+    const p = getConfigPath();
+    const legacy = getLegacyConfigPath();
+    // Try canonical first, then legacy
+    for (const file of [p, legacy]) {
+        try {
+            const raw = await fs.readFile(file, 'utf-8');
+            const obj = parseJsonc(raw, file);
+            return validateConfig(obj, file);
+        }
+        catch (err) {
+            const e = err;
+            if (e.code === 'ENOENT')
+                continue;
+            if (err instanceof KlyroError)
+                throw err;
+            throw new KlyroError('CONFIG_INVALID', `cannot read ${file}: ${e.message}`, { exitCode: 3 });
+        }
+    }
+    return {};
+}
+// --- Merged load with 5-layer precedence ---
+export async function loadMergedConfig(cwd = process.cwd(), flags = {}) {
+    const layers = [];
+    // 1) defaults (empty)
+    layers.push({});
+    // 2) ~/.klyro/settings.json
+    for (const file of [path.join(getConfigDir(), 'settings.json'), getLegacyConfigPath()]) {
+        try {
+            const raw = await fs.readFile(file, 'utf-8');
+            const obj = parseJsonc(raw, file);
+            layers.push(validateConfig(obj, file));
+        }
+        catch (err) {
+            const e = err;
+            if (e.code === 'ENOENT')
+                continue;
+            throw err;
+        }
+    }
+    // 3) .klyro/settings.json
+    try {
+        const raw = await fs.readFile(path.join(cwd, '.klyro', 'settings.json'), 'utf-8');
+        const obj = parseJsonc(raw, path.join(cwd, '.klyro/settings.json'));
+        layers.push(validateConfig(obj, path.join(cwd, '.klyro/settings.json')));
+    }
+    catch (err) {
+        const e = err;
+        if (e.code !== 'ENOENT')
+            throw err;
+    }
+    // 4) .klyro/settings.local.json
+    try {
+        const raw = await fs.readFile(path.join(cwd, '.klyro', 'settings.local.json'), 'utf-8');
+        const obj = parseJsonc(raw, path.join(cwd, '.klyro/settings.local.json'));
+        layers.push(validateConfig(obj, path.join(cwd, '.klyro/settings.local.json')));
+    }
+    catch (err) {
+        const e = err;
+        if (e.code !== 'ENOENT')
+            throw err;
+    }
+    // 5) env
+    const envLayer = {};
+    if (process.env.KLYRO_MODEL)
+        envLayer.model = process.env.KLYRO_MODEL;
+    if (process.env.KLYRO_PROVIDER)
+        envLayer.provider = process.env.KLYRO_PROVIDER;
+    if (process.env.KLYRO_BASE_URL)
+        envLayer.baseUrl = process.env.KLYRO_BASE_URL;
+    if (process.env.KLYRO_API_KEY)
+        envLayer.apiKey = process.env.KLYRO_API_KEY;
+    if (process.env.OPENAI_API_KEY)
+        envLayer.apiKey = process.env.OPENAI_API_KEY;
+    if (process.env.ANTHROPIC_API_KEY)
+        envLayer.apiKey = process.env.ANTHROPIC_API_KEY;
+    layers.push(envLayer);
+    // 6) flags (highest)
+    layers.push(flags);
+    // Merge shallow (dotted keys are already nested via setByPath, but we treat flat)
+    const merged = {};
+    for (const layer of layers) {
+        for (const [k, v] of Object.entries(layer)) {
+            if (v !== undefined)
+                setByPath(merged, k, v);
+        }
+    }
+    return merged;
+}
+export async function saveConfig(obj) {
+    const p = getConfigPath();
+    await fs.mkdir(path.dirname(p), { recursive: true });
+    const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
+    const data = JSON.stringify(validateConfig(obj, p), null, 2) + '\n';
+    await fs.writeFile(tmp, data, { mode: 0o600 });
+    try {
+        await fs.rename(tmp, p);
+    }
+    catch (err) {
+        await fs.unlink(tmp).catch(() => undefined);
+        throw err;
+    }
+    try {
+        await fs.chmod(p, 0o600);
+    }
+    catch { /* ignore on Windows */ }
+}
+export async function runConfig(args) {
+    const [cmd, ...rest] = args;
+    const cfgPath = getConfigPath();
+    if (!cmd || cmd === 'list') {
+        try {
+            const cfg = await loadMergedConfig(process.cwd(), {});
+            if (Object.keys(cfg).length === 0) {
+                process.stdout.write(`# ${cfgPath} (empty)\n# No config yet. Use: klyro config set <key> <value>\n`);
+            }
+            else {
+                process.stdout.write(JSON.stringify(cfg, null, 2) + '\n');
+            }
+            return 0;
+        }
+        catch (err) {
+            if (err instanceof KlyroError) {
+                process.stderr.write(`✖ ${err.message}\n hint: ${err.hint ?? ''}\n`);
+                return err.exitCode;
+            }
+            throw err;
+        }
+    }
+    if (cmd === 'path') {
+        const paths = getConfigSearchPaths(process.cwd());
+        for (const p of paths) {
+            const status = p.exists ? 'exists' : 'missing';
+            process.stdout.write(`${p.layer}: ${p.path} [${status}]\n`);
+        }
+        // Also show env
+        process.stdout.write(`env: KLYRO_MODEL=${process.env.KLYRO_MODEL ?? '(not set)'} KLYRO_PROVIDER=${process.env.KLYRO_PROVIDER ?? '(not set)'}\n`);
+        return 0;
+    }
+    if (cmd === 'edit') {
+        const p = getConfigPath();
+        // Try to open $EDITOR
+        const editor = process.env.EDITOR || process.env.VISUAL;
+        if (editor) {
+            const { spawn } = await import('node:child_process');
+            const child = spawn(editor, [p], { stdio: 'inherit', shell: true });
+            const code = await new Promise((res) => child.on('close', (c) => res(typeof c === 'number' ? c : 1)));
+            return code;
+        }
+        process.stderr.write('klyro: config edit — open ' + p + ' in $EDITOR\n');
+        process.stdout.write(p + '\n');
+        return 0;
+    }
+    if (cmd === 'get') {
+        const key = rest[0];
+        if (!key) {
+            process.stderr.write('klyro: config get <key> — missing key\n');
+            return 2;
+        }
+        try {
+            const cfg = await loadMergedConfig(process.cwd(), {});
+            const val = getByPath(cfg, key);
+            if (val === undefined) {
+                process.stderr.write(`klyro: key not found: ${key}\n`);
+                return 1;
+            }
+            if (typeof val === 'string')
+                process.stdout.write(val + '\n');
+            else
+                process.stdout.write(JSON.stringify(val, null, 2) + '\n');
+            return 0;
+        }
+        catch (err) {
+            if (err instanceof KlyroError) {
+                process.stderr.write(`✖ ${err.message}\n hint: ${err.hint ?? ''}\n`);
+                return err.exitCode;
+            }
+            throw err;
+        }
+    }
+    if (cmd === 'set') {
+        const key = rest[0];
+        const rawVal = rest.slice(1).join(' ');
+        if (!key) {
+            process.stderr.write('klyro: config set <key> <value> — missing key\n');
+            return 2;
+        }
+        if (rawVal === '' && rest.length < 2) {
+            process.stderr.write('klyro: config set <key> <value> — missing value\n');
+            return 2;
+        }
+        try {
+            const cfg = await loadConfig();
+            const val = parseValue(rawVal);
+            setByPath(cfg, key, val);
+            // Validate before save
+            validateConfig(cfg, cfgPath);
+            await saveConfig(cfg);
+            process.stdout.write(`set ${key} = ${typeof val === 'string' ? val : JSON.stringify(val)}\n`);
+            return 0;
+        }
+        catch (err) {
+            if (err instanceof KlyroError) {
+                process.stderr.write(`✖ ${err.message}\n hint: ${err.hint ?? ''}\n`);
+                return err.exitCode;
+            }
+            throw err;
+        }
+    }
+    if (cmd === 'unset' || cmd === 'delete' || cmd === 'rm') {
+        const key = rest[0];
+        if (!key) {
+            process.stderr.write(`klyro: config ${cmd} <key> — missing key\n`);
+            return 2;
+        }
+        const cfg = await loadConfig();
+        const ok = deleteByPath(cfg, key);
+        if (!ok) {
+            process.stderr.write(`klyro: key not found: ${key}\n`);
+            return 1;
+        }
+        await saveConfig(cfg);
+        process.stdout.write(`unset ${key}\n`);
+        return 0;
+    }
+    process.stderr.write(`klyro: unknown config command: ${cmd}\n`);
+    process.stderr.write('Usage: klyro config [list|get <key>|set <key> <value>|unset <key>|path|edit]\n');
+    return 2;
+}
+export const _helpers = { getByPath, setByPath, deleteByPath, parseValue, stripJsonComments: stripJsonComments };

package/dist/cli/doctor.d.ts

@@ -0,0 +1,8 @@
+/**
+ * LEVEL 1 — klyro doctor
+ * Runs quick diagnostics: node version, config, provider reachability,
+ * persistence dir, git, tools.
+ */
+export declare function runDoctor(opts?: {
+    json?: boolean;
+}): Promise<number>;