klyro 0.1.1

package/dist/verification/detect.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Failure-type classifier + diagnostic parser. Given the stderr/stdout of
+ * a verify command, decide which kind of failure it represents and pull
+ * out a structured Failure object the runtime can feed back to the model.
+ *
+ * Supported types: 'type' (TypeScript tsc), 'test' (vitest/jest/mocha),
+ * 'lint' (eslint), 'build' (esbuild/webpack/tsc bundled), 'runtime'
+ * (uncaught exception).
+ *
+ * This is intentionally a heuristic, not a parser. The model still sees
+ * the raw output; we just pre-structure the high-signal lines.
+ */
+export type FailureType = 'type' | 'test' | 'lint' | 'build' | 'runtime' | 'unknown';
+export interface FailureFile {
+    path: string;
+    line?: number;
+    column?: number;
+    message: string;
+    code?: string;
+}
+export interface Failure {
+    type: FailureType;
+    files: FailureFile[];
+    raw: string;
+    exitCode: number;
+}
+export declare function detect(stdout: string, stderr: string, exitCode: number): Failure;
+/** Build a short, structured summary the model can act on. */
+export declare function summarize(failure: Failure): string;

package/dist/verification/detect.js

@@ -0,0 +1,85 @@
+/**
+ * Failure-type classifier + diagnostic parser. Given the stderr/stdout of
+ * a verify command, decide which kind of failure it represents and pull
+ * out a structured Failure object the runtime can feed back to the model.
+ *
+ * Supported types: 'type' (TypeScript tsc), 'test' (vitest/jest/mocha),
+ * 'lint' (eslint), 'build' (esbuild/webpack/tsc bundled), 'runtime'
+ * (uncaught exception).
+ *
+ * This is intentionally a heuristic, not a parser. The model still sees
+ * the raw output; we just pre-structure the high-signal lines.
+ */
+const TS_LINE = /^(.+?)\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.+)$/;
+const TEST_FAIL = /^\s*✘|FAIL\s+(\S+)|✗\s+(\S+)|×\s+(.+?)\s/;
+const LINT_LINE = /^(.+?)\s*$/;
+const RUNTIME_LINE = /^(?:Error|TypeError|ReferenceError):\s+(.+)$/;
+export function detect(stdout, stderr, exitCode) {
+    const combined = stderr + '\n' + stdout;
+    if (exitCode === 0) {
+        return { type: 'unknown', files: [], raw: combined, exitCode };
+    }
+    // TypeScript tsc.
+    const tsMatches = [];
+    for (const line of combined.split(/\r?\n/)) {
+        const m = TS_LINE.exec(line);
+        if (m && m[1] && m[2] && m[3] && m[4] && m[5]) {
+            tsMatches.push({ path: m[1], line: Number(m[2]), column: Number(m[3]), code: m[4], message: m[5] });
+        }
+    }
+    if (tsMatches.length > 0)
+        return { type: 'type', files: tsMatches, raw: combined, exitCode };
+    // Test runner.
+    if (/Test Suites:|FAIL\s|Tests:.*failed|✘|✗/.test(combined)) {
+        const files = [];
+        for (const line of combined.split(/\r?\n/)) {
+            const m = TEST_FAIL.exec(line);
+            if (m) {
+                const target = m[1] ?? m[2] ?? m[3] ?? line.trim();
+                files.push({ path: target, message: line.trim() });
+            }
+        }
+        return { type: 'test', files, raw: combined, exitCode };
+    }
+    // ESLint.
+    if (/error\s+at\s+|eslint.*problem|✖/.test(combined)) {
+        return { type: 'lint', files: extractFirstLines(combined, 5), raw: combined, exitCode };
+    }
+    // Runtime exception.
+    const lines = combined.split(/\r?\n/);
+    const rt = lines.some((l) => RUNTIME_LINE.test(l));
+    if (rt) {
+        return { type: 'runtime', files: extractFirstLines(combined, 5), raw: combined, exitCode };
+    }
+    // Generic build.
+    if (/error/i.test(combined)) {
+        return { type: 'build', files: extractFirstLines(combined, 5), raw: combined, exitCode };
+    }
+    return { type: 'unknown', files: extractFirstLines(combined, 3), raw: combined, exitCode };
+}
+function extractFirstLines(s, n) {
+    return s
+        .split(/\r?\n/)
+        .filter((l) => l.trim().length > 0)
+        .slice(0, n)
+        .map((message) => ({ path: '', message }));
+}
+/** Build a short, structured summary the model can act on. */
+export function summarize(failure) {
+    if (failure.files.length === 0) {
+        return `Verification failed (exit ${failure.exitCode}, type=${failure.type}). No structured files parsed; see raw output below.\n\n${truncate(failure.raw, 2000)}`;
+    }
+    const lines = [`Verification failed (${failure.type}, exit ${failure.exitCode}).`];
+    for (const f of failure.files.slice(0, 8)) {
+        const loc = f.line ? `:${f.line}${f.column ? `:${f.column}` : ''}` : '';
+        const code = f.code ? ` [${f.code}]` : '';
+        lines.push(`- ${f.path}${loc}${code} — ${f.message}`);
+    }
+    lines.push('');
+    lines.push('Raw output (truncated):');
+    lines.push(truncate(failure.raw, 1500));
+    return lines.join('\n');
+}
+function truncate(s, n) {
+    return s.length > n ? s.slice(0, n) + '\n... [truncated]' : s;
+}

package/dist/verification/engine.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Verification engine — run a command, classify failures, and run a
+ * bounded repair loop. The model is asked to fix the same task again
+ * with the structured diagnostic injected as a user message.
+ *
+ * On success: returns { ok: true }.
+ * On failure: returns { ok: false, failure } with the most recent
+ * structured Failure (and the model has had up to N attempts to fix).
+ */
+import { type Failure } from './detect.js';
+export interface VerifyOptions {
+    cwd: string;
+    command: string;
+    timeoutMs?: number;
+}
+export interface VerifyResult {
+    ok: boolean;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    failure?: Failure;
+}
+export declare function verify(opts: VerifyOptions): Promise<VerifyResult>;
+/** Format a failure for injection into the model's transcript. */
+export declare function diagnosticForModel(result: VerifyResult): string;

package/dist/verification/engine.js

@@ -0,0 +1,57 @@
+/**
+ * Verification engine — run a command, classify failures, and run a
+ * bounded repair loop. The model is asked to fix the same task again
+ * with the structured diagnostic injected as a user message.
+ *
+ * On success: returns { ok: true }.
+ * On failure: returns { ok: false, failure } with the most recent
+ * structured Failure (and the model has had up to N attempts to fix).
+ */
+import { spawn } from 'node:child_process';
+import { detect, summarize } from './detect.js';
+export async function verify(opts) {
+    const timeout = opts.timeoutMs ?? 5 * 60 * 1000;
+    return new Promise((resolve) => {
+        const child = spawn(opts.command, { cwd: opts.cwd, shell: true, env: process.env });
+        let stdout = '';
+        let stderr = '';
+        let done = false;
+        const timer = setTimeout(() => {
+            if (done)
+                return;
+            child.kill();
+            done = true;
+            const raw = stderr + '\n' + stdout;
+            resolve({
+                ok: false,
+                exitCode: -1,
+                stdout,
+                stderr: stderr + '\n[verify timeout]',
+                failure: { type: 'runtime', files: [], raw, exitCode: -1 },
+            });
+        }, timeout);
+        child.stdout.on('data', (b) => { stdout += b.toString(); });
+        child.stderr.on('data', (b) => { stderr += b.toString(); });
+        child.on('close', (code) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            const exit = typeof code === 'number' ? code : -1;
+            if (exit === 0) {
+                resolve({ ok: true, exitCode: 0, stdout, stderr });
+                return;
+            }
+            const failure = detect(stdout, stderr, exit);
+            resolve({ ok: false, exitCode: exit, stdout, stderr, failure });
+        });
+    });
+}
+/** Format a failure for injection into the model's transcript. */
+export function diagnosticForModel(result) {
+    if (result.ok)
+        return 'Verification passed.';
+    if (!result.failure)
+        return `Verification failed with exit ${result.exitCode}.`;
+    return summarize(result.failure);
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "klyro",
+  "version": "0.1.1",
+  "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",
+  "bin": {
+    "klyro": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "dev:watch": "tsx watch src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build",
+    "pack:dry": "npm pack --dry-run",
+    "publish:public": "npm publish --access public"
+  },
+  "keywords": [
+    "llm",
+    "ai",
+    "cli",
+    "openai",
+    "anthropic",
+    "harness",
+    "agent",
+    "streaming",
+    "klyro"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^12.1.0",
+    "ink": "^7.1.1",
+    "ink-spinner": "^5.0.0",
+    "react": "^19.2.0",
+    "zod": "^4.5.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.9.0",
+    "@types/react": "^19.2.18",
+    "ink-testing-library": "^4.0.0",
+    "tsx": "^4.23.13",
+    "typescript": "^5.5.4",
+    "vitest": "^4.1.11"
+  }
+}