klyro 0.1.3 → 0.1.5

package/dist/cli/doctor.js

@@ -0,0 +1,136 @@
+/**
+ * LEVEL 1 — klyro doctor
+ * Runs quick diagnostics: node version, config, provider reachability,
+ * persistence dir, git, tools.
+ */
+import * as fs from 'node:fs/promises';
+import * as fsSync from 'node:fs';
+import * as path from 'node:path';
+import { spawn } from 'node:child_process';
+import { getConfigPath, loadConfig } from './config.js';
+import { resolveProvider, providerHelp } from '../providers.js';
+import { getDefaultSessionsDir } from '../persistence/session.js';
+import { builtinRegistry } from '../tools/registry.js';
+function checkNode() {
+    const v = process.versions.node;
+    const major = Number(v.split('.')[0] ?? 0);
+    const ok = major >= 20;
+    return {
+        name: 'Node.js',
+        ok,
+        detail: `${v} ${ok ? '✓' : '✗ requires >=20'} (${process.execPath})`,
+    };
+}
+async function checkConfig() {
+    const p = getConfigPath();
+    try {
+        await loadConfig();
+        const exists = fsSync.existsSync(p);
+        return { name: 'Config', ok: true, detail: exists ? `${p} ✓` : `${p} (not yet created) ✓` };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { name: 'Config', ok: false, detail: `${p} ✗ ${msg}` };
+    }
+}
+async function checkProvider() {
+    try {
+        const prov = await resolveProvider();
+        if (!prov) {
+            return { name: 'Provider', ok: false, detail: `none ${providerHelp(null)}` };
+        }
+        const src = prov.source === 'local-probe' ? 'local-probe' : prov.source === 'env' ? 'env' : 'manual';
+        const auth = prov.apiKey ? 'key set' : 'no key (local)';
+        return { name: 'Provider', ok: true, detail: `${prov.baseURL} model=${prov.model} (${src}, ${auth}) ✓` };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { name: 'Provider', ok: false, detail: `error: ${msg}` };
+    }
+}
+async function checkSessions() {
+    const dir = getDefaultSessionsDir();
+    try {
+        await fs.mkdir(dir, { recursive: true });
+        const test = path.join(dir, `.doctor-${Date.now()}.tmp`);
+        await fs.writeFile(test, 'ok', 'utf-8');
+        await fs.unlink(test);
+        return { name: 'Sessions dir', ok: true, detail: `${dir} writable ✓` };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { name: 'Sessions dir', ok: false, detail: `${dir} ✗ ${msg}` };
+    }
+}
+function checkGit() {
+    return new Promise((resolve) => {
+        const child = spawn('git', ['--version'], { shell: false, windowsHide: true });
+        let out = '';
+        let done = false;
+        const timer = setTimeout(() => {
+            if (done)
+                return;
+            done = true;
+            child.kill();
+            resolve({ name: 'git', ok: false, detail: 'timeout' });
+        }, 3000);
+        child.stdout.on('data', (b) => { out += b.toString(); });
+        child.on('error', () => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            resolve({ name: 'git', ok: false, detail: 'not found (install git)' });
+        });
+        child.on('close', (code) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            if (code === 0)
+                resolve({ name: 'git', ok: true, detail: out.trim() + ' ✓' });
+            else
+                resolve({ name: 'git', ok: false, detail: `exit ${code}` });
+        });
+    });
+}
+function checkTools() {
+    const reg = builtinRegistry();
+    return { name: 'Tools', ok: true, detail: `${reg.list().length} tools: ${reg.list().map((t) => t.name).join(', ')}` };
+}
+function checkPlatform() {
+    const ok = ['win32', 'linux', 'darwin'].includes(process.platform);
+    return { name: 'Platform', ok, detail: `${process.platform} ${process.arch} ${ok ? '✓' : '✗ unsupported'}` };
+}
+export async function runDoctor(opts = {}) {
+    const checks = [];
+    checks.push(checkNode());
+    checks.push(await checkConfig());
+    checks.push(await checkProvider());
+    checks.push(await checkSessions());
+    checks.push(await checkGit());
+    checks.push(checkTools());
+    checks.push(checkPlatform());
+    const allOk = checks.every((c) => c.ok);
+    if (opts.json) {
+        process.stdout.write(JSON.stringify({ ok: allOk, checks }, null, 2) + '\n');
+        return allOk ? 0 : 1;
+    }
+    process.stdout.write('\nklyro doctor\n');
+    process.stdout.write('─'.repeat(40) + '\n');
+    for (const c of checks) {
+        const glyph = c.ok ? '✓' : '✗';
+        const color = c.ok ? '' : '';
+        process.stdout.write(`${glyph} ${c.name.padEnd(14)} ${c.detail}\n`);
+    }
+    process.stdout.write('─'.repeat(40) + '\n');
+    if (allOk) {
+        process.stdout.write('All checks passed.\n');
+    }
+    else {
+        process.stdout.write('Some checks failed — see ✗ above. Fix env/config and re-run.\n');
+        process.stdout.write(`Config path: ${getConfigPath()}\n`);
+        process.stdout.write(`Sessions : ${getDefaultSessionsDir()}\n`);
+    }
+    return allOk ? 0 : 1;
+}

package/dist/cli/errors.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 1.5 — handleFatal: ✖ message / hint: / "run with --debug", mapped exit codes
+ */
+export declare function handleFatal(err: unknown): never;
+export declare function setupGlobalHandlers(): void;

package/dist/cli/errors.js

@@ -0,0 +1,37 @@
+/**
+ * 1.5 — handleFatal: ✖ message / hint: / "run with --debug", mapped exit codes
+ */
+import { KlyroError } from '../shared/errors.js';
+export function handleFatal(err) {
+    const isDebug = !!process.env.KLYRO_LOG_LEVEL || !!process.env.DEBUG || process.argv.includes('--debug');
+    let code = 1;
+    let message = err instanceof Error ? err.message : String(err);
+    let hint;
+    if (err instanceof KlyroError) {
+        code = err.exitCode;
+        hint = err.hint;
+    }
+    else if (err instanceof Error && err.code === 'ENOENT') {
+        code = 2;
+        hint = 'Check the file path exists';
+    }
+    // Never print stack without --debug
+    if (!isDebug) {
+        // Strip stack, only print message
+        process.stderr.write(`✖ ${message}\n`);
+    }
+    else {
+        process.stderr.write(`✖ ${message}\n`);
+        if (err instanceof Error && err.stack)
+            process.stderr.write(err.stack + '\n');
+    }
+    if (hint)
+        process.stderr.write(`  hint: ${hint}\n`);
+    if (!isDebug)
+        process.stderr.write('  run with --debug for stack trace\n');
+    process.exit(code);
+}
+export function setupGlobalHandlers() {
+    process.on('uncaughtException', (err) => handleFatal(err));
+    process.on('unhandledRejection', (reason) => handleFatal(reason));
+}

package/dist/cli/markdown.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 1.5 — incremental markdown renderer (headers, code w/ highlight, lists, tables)
+ * Minimal: handles headers, code blocks, lists, tables, width-aware wrap, plain-text for non-TTY.
+ */
+export declare function renderMarkdown(md: string, opts?: {
+    width?: number;
+    isTTY?: boolean;
+}): string;
+export declare function renderIncremental(prev: string, nextChunk: string): string;

package/dist/cli/markdown.js

@@ -0,0 +1,77 @@
+/**
+ * 1.5 — incremental markdown renderer (headers, code w/ highlight, lists, tables)
+ * Minimal: handles headers, code blocks, lists, tables, width-aware wrap, plain-text for non-TTY.
+ */
+export function renderMarkdown(md, opts = {}) {
+    const width = opts.width ?? (process.stdout.columns || 80);
+    const isTTY = opts.isTTY ?? !!process.stdout.isTTY;
+    if (!isTTY || process.env.KLYRO_JSON === '1' || process.env.NO_COLOR === '1') {
+        // Plain text: strip markdown decorations
+        return stripMarkdown(md);
+    }
+    let out = '';
+    const lines = md.split('\n');
+    let inCodeBlock = false;
+    for (let line of lines) {
+        if (line.startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            out += (inCodeBlock ? '┌ code ──\n' : '└──────\n');
+            continue;
+        }
+        if (inCodeBlock) {
+            out += '│ ' + line + '\n';
+            continue;
+        }
+        if (line.startsWith('# ')) {
+            out += '\n' + line.replace(/^#\s+/, '').toUpperCase() + '\n' + '─'.repeat(Math.min(width, 40)) + '\n';
+            continue;
+        }
+        if (line.startsWith('## ')) {
+            out += '\n' + line.replace(/^##\s+/, '') + '\n';
+            continue;
+        }
+        if (line.startsWith('- ') || line.startsWith('* ')) {
+            out += '• ' + line.slice(2) + '\n';
+            continue;
+        }
+        if (line.startsWith('|') && line.endsWith('|')) {
+            // Table row: replace | with │ and trim
+            const cells = line.split('|').filter(Boolean).map((c) => c.trim());
+            out += '│ ' + cells.join(' │ ') + ' │\n';
+            continue;
+        }
+        // Wrap long lines
+        if (line.length > width) {
+            const words = line.split(' ');
+            let cur = '';
+            for (const w of words) {
+                if ((cur + ' ' + w).length > width) {
+                    out += cur.trimEnd() + '\n';
+                    cur = w + ' ';
+                }
+                else {
+                    cur += w + ' ';
+                }
+            }
+            if (cur.trim())
+                out += cur.trimEnd() + '\n';
+        }
+        else {
+            out += line + '\n';
+        }
+    }
+    return out;
+}
+function stripMarkdown(md) {
+    return md
+        .replace(/^#+\s+/gm, '')
+        .replace(/```[\s\S]*?```/g, (m) => m.replace(/```/g, '').trim())
+        .replace(/\*\*(.+?)\*\*/g, '$1')
+        .replace(/\*(.+?)\*/g, '$1')
+        .replace(/`(.+?)`/g, '$1')
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+}
+export function renderIncremental(prev, nextChunk) {
+    // For streaming, just append and re-render last chunk
+    return renderMarkdown(prev + nextChunk);
+}

package/dist/cli/repl.d.ts

@@ -11,5 +11,7 @@ export interface ReplOptions {
     maxSteps?: number;
     model?: string;
     nonInteractive?: boolean;
+    /** Force TUI even when stdin is not a TTY (e.g. for testing or explicit flag). */
+    forceTty?: boolean;
 }
 export declare function startRepl(opts?: ReplOptions): Promise<number>;