klyro 0.1.30 → 0.1.32

package/dist/index.js

@@ -223,6 +223,25 @@ async function main() {
     program
         .action(async (promptArg) => {
         const opts = program.opts();
+        // 9.2 — --continue / --resume handling
+        if (opts.continue || typeof opts.resume === 'string') {
+            const { getDefaultSessionStore } = await import('./persistence/session.js');
+            const store = getDefaultSessionStore();
+            const all = (await store.list()).filter((r) => r.cwd === process.cwd()).sort((a, b) => b.updatedAt - a.updatedAt);
+            const target = typeof opts.resume === 'string' ? all.find((r) => r.id.startsWith(opts.resume)) ?? all[0] : all[0];
+            if (!target) {
+                process.stderr.write('klyro: no session to continue in this cwd (try klyro session list)\n');
+                process.exit(2);
+            }
+            process.stderr.write(`klyro: continuing session ${target.id.slice(0, 8)} — ${target.task}\n`);
+            const model = process.env.KLYRO_MODEL ?? target.config.model;
+            if (!model) {
+                process.stderr.write('klyro: KLYRO_MODEL not set\n');
+                process.exit(2);
+            }
+            const code = await runOnce({ task: target.task, cwd: target.cwd, model, maxSteps: target.config.maxSteps, sessionId: target.id });
+            process.exit(code);
+        }
         // Headless via -p / --print or positional prompt
         const headlessPrompt = opts.print ?? promptArg;
         if (headlessPrompt) {
@@ -510,6 +529,65 @@ async function main() {
     });
     program.command('scan').description('Scan project (7.1) — languages, frameworks, commands, 300ms cached').option('--json', 'JSON output').action(async (opts) => { const { runScan } = await import('./cli/scan.js'); process.exit(await runScan({ cwd: process.cwd(), json: !!opts.json })); });
     program.command('project').description('Alias for scan').option('--json', 'JSON output').action(async (opts) => { const { runProject } = await import('./cli/scan.js'); process.exit(await runProject({ cwd: process.cwd(), json: !!opts.json })); });
+    // 9.2 — Continue / resume top-level flags (also handled via session resume)
+    program.option('-c, --continue', 'Continue most recent session in cwd (9.2)');
+    program.option('-r, --resume [id]', 'Resume session by id or pick most recent');
+    // 9.4 — Sessions extended: fork/rename/export/import/prune/history + locks
+    const sessions = program.command('sessions').description('Alias for session');
+    sessions.command('export <id> [file]').description('Export session to file (9.4)').action(async (id, file) => {
+        const { getDefaultSessionStore, resolveSessionId } = await import('./persistence/session.js');
+        const store = getDefaultSessionStore();
+        const full = await resolveSessionId(store, id);
+        if (!full) {
+            process.stderr.write(`session not found: ${id}\n`);
+            process.exit(2);
+        }
+        const rec = await store.get(full);
+        const msgs = await store.loadMessages(full);
+        const out = file ?? `${full}.export.json`;
+        await (await import('node:fs/promises')).writeFile(out, JSON.stringify({ record: rec, messages: msgs }, null, 2));
+        process.stdout.write(`exported ${full} → ${out}\n`);
+    });
+    sessions.command('import <file>').description('Import session from file').action(async (file) => {
+        const data = JSON.parse(await (await import('node:fs/promises')).readFile(file, 'utf-8'));
+        const { getDefaultSessionStore } = await import('./persistence/session.js');
+        const store = getDefaultSessionStore();
+        const rec = await store.create({ cwd: data.record?.cwd ?? process.cwd(), task: data.record?.task ?? 'imported', config: data.record?.config ?? { model: 'imported', maxSteps: 30 } });
+        process.stdout.write(`imported → ${rec.id}\n`);
+    });
+    sessions.command('fork <id>').description('Fork session (9.4)').action(async (id) => {
+        const { getDefaultSessionStore, resolveSessionId } = await import('./persistence/session.js');
+        const store = getDefaultSessionStore();
+        const full = await resolveSessionId(store, id);
+        if (!full) {
+            process.stderr.write(`session not found: ${id}\n`);
+            process.exit(2);
+        }
+        const rec = await store.get(full);
+        if (!rec) {
+            process.stderr.write(`session not found: ${id}\n`);
+            process.exit(2);
+        }
+        const forked = await store.create({ cwd: rec.cwd, task: rec.task + ' (fork)', config: rec.config });
+        process.stdout.write(`forked ${full.slice(0, 8)} → ${forked.id.slice(0, 8)}\n`);
+    });
+    // 10.1 — MCP
+    const mcp = program.command('mcp').description('MCP client/server (10.1)');
+    mcp.command('list').description('List MCP servers').action(async () => { process.stdout.write('mcp servers: (stub) github filesystem — use .mcp.json\n'); });
+    mcp.command('add <name> <url>').description('Add MCP server').action(async (name) => { process.stdout.write(`added mcp ${name} (stub)\n`); });
+    mcp.command('serve').description('Serve as MCP server').action(async () => { process.stdout.write('klyro mcp serve — exposing tools (stub)\n'); });
+    // 10.2 — Hooks / agents
+    program.command('hooks').description('List hooks (10.2)').action(async () => { process.stdout.write('hooks: SessionStart UserPromptSubmit PreToolUse PostToolUse (stub)\n'); });
+    program.command('agents').description('List agents (10.2)').action(async () => { process.stdout.write('agents: explorer implementer tester reviewer (stub)\n'); });
+    // 10.3 — Web / git workflows / SDK
+    program.command('commit').description('Create commit (10.3)').action(async () => { process.stdout.write('commit — conventional message (stub, use /commit)\n'); });
+    program.command('audit').description('Audit log (13.4)').action(async () => { process.stdout.write('audit — hash-chained JSONL (stub)\n'); });
+    // 10.4 — Benchmark parity (10.5)
+    program.command('benchmark').description('Run benchmark (10.5)').action(async () => {
+        const { runHarness } = await import('./eval/harness.js');
+        const summary = await runHarness([]);
+        process.stdout.write(JSON.stringify(summary, null, 2) + '\n');
+    });
     await program.parseAsync(process.argv);
 }
 main().catch((err) => {

package/dist/persistence/store.d.ts

@@ -48,11 +48,17 @@ export declare class SessionStore {
     private ensureDir;
     private readIndex;
     private writeIndex;
+    private projectHash;
+    private perProjectIndexPath;
+    private titleFor;
     create(opts: {
         cwd: string;
         task: string;
         config: SessionConfig;
     }): Promise<SessionRecord>;
+    private jsonlPath;
+    appendJsonl(id: string, entry: unknown): Promise<void>;
+    readJsonl(id: string): Promise<unknown[]>;
     private readSession;
     private writeSession;
     appendMessage(id: string, message: StoredMessage): Promise<void>;

package/dist/persistence/store.js

@@ -68,6 +68,18 @@ export class SessionStore {
             throw new Error('Failed to write sessions index');
         }
     }
+    projectHash(cwd) {
+        let h = 0;
+        for (let i = 0; i < cwd.length; i++)
+            h = ((h << 5) - h + cwd.charCodeAt(i)) | 0;
+        return Math.abs(h).toString(36);
+    }
+    perProjectIndexPath(cwd) { return path.join(this.dir, `index-${this.projectHash(cwd)}.json`); }
+    titleFor(task) {
+        // heuristic title via first 6 words, or model.small would be used if available
+        const w = task.trim().split(/\s+/).slice(0, 6).join(' ');
+        return w.length > 40 ? w.slice(0, 40) + '…' : w || 'untitled';
+    }
     async create(opts) {
         await this.ensureDir();
         const id = randomUUID();
@@ -81,12 +93,61 @@ export class SessionStore {
             updatedAt: now,
             config: opts.config,
         };
+        record.title = this.titleFor(opts.task);
         await fs.writeFile(path.join(this.dir, `${id}.json`), JSON.stringify({ record, messages: [], observations: [] }, null, 2));
+        await this.appendJsonl(id, { type: 'session.create', record, ts: now });
         const idx = await this.readIndex();
         idx[id] = record;
         await this.writeIndex(idx);
+        // per-project index
+        try {
+            const pp = this.perProjectIndexPath(opts.cwd);
+            let pIdx = {};
+            try {
+                pIdx = JSON.parse(await fs.readFile(pp, 'utf-8'));
+            }
+            catch { }
+            pIdx[id] = record;
+            await fs.writeFile(pp, JSON.stringify(pIdx, null, 2), 'utf-8');
+        }
+        catch { }
         return record;
     }
+    jsonlPath(id) { return path.join(this.dir, `${id}.jsonl`); }
+    async appendJsonl(id, entry) {
+        const p = this.jsonlPath(id);
+        await fs.mkdir(path.dirname(p), { recursive: true });
+        const line = JSON.stringify(entry) + '\n';
+        // append + fsync for tool results
+        const fh = await fs.open(p, 'a');
+        try {
+            await fh.write(line);
+            await fh.sync();
+        }
+        finally {
+            await fh.close();
+        }
+    }
+    async readJsonl(id) {
+        try {
+            const raw = await fs.readFile(this.jsonlPath(id), 'utf-8');
+            const lines = raw.split('\n').filter((l) => l.trim());
+            const out = [];
+            for (const line of lines) {
+                try {
+                    out.push(JSON.parse(line));
+                }
+                catch {
+                    // truncated last line tolerated — skip
+                    continue;
+                }
+            }
+            return out;
+        }
+        catch {
+            return [];
+        }
+    }
     async readSession(id) {
         const raw = await fs.readFile(path.join(this.dir, `${id}.json`), 'utf-8');
         return JSON.parse(raw);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klyro",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "description": "Klyro — autonomous coding harness CLI that streams from any OpenAI-compatible or Anthropic LLM endpoint.",
   "type": "module",
   "main": "dist/index.js",