klyro 1.0.18 → 1.0.20

package/dist/agent/runtime.js

@@ -1082,6 +1082,7 @@ export async function run(opts, deps) {
                     await snapshot(opts.cwd, [...fileEditCounts.keys()].slice(-20), {
                         ...(sessionId !== undefined ? { sessionId } : {}),
                         eventId: call.id,
+                        transcript,
                     });
                 }
                 catch { /* ignore */ }
@@ -1176,6 +1177,7 @@ export async function run(opts, deps) {
                         await snapshot(opts.cwd, [fileChanged.path], {
                             ...(sessionId !== undefined ? { sessionId } : {}),
                             eventId: call.id,
+                            transcript,
                         });
                     }
                     catch { /* ignore */ }

package/dist/checkpoints/store.d.ts

@@ -14,6 +14,7 @@
 export interface SnapshotOptions {
     sessionId?: string;
     eventId?: string;
+    transcript?: unknown[];
 }
 /** Checkpoint meta on disk — sessionId/eventId are absent on old metas. */
 export interface CheckpointMeta {
@@ -23,6 +24,7 @@ export interface CheckpointMeta {
     ts: number;
     sessionId?: string;
     eventId?: string;
+    transcriptHash?: string;
 }
 export declare function snapshot(cwd: string, files: string[], opts?: SnapshotOptions): Promise<string>;
 export declare function listCheckpoints(cwd: string): Promise<string[]>;
@@ -37,6 +39,17 @@ export interface CheckpointInfo {
 export declare function listCheckpointInfo(cwd: string): Promise<CheckpointInfo[]>;
 /** File paths a snapshot would restore (for `/rewind <n> preview`). */
 export declare function snapshotFiles(cwd: string, id: string): Promise<string[]>;
+/**
+ * Transcript captured at a checkpoint, or null when the snapshot predates
+ * transcript capture or the payload is missing/corrupt.
+ *
+ * The stored hash is verified on read: a checkpoint is only ever trusted for
+ * restoring the conversation when its transcript.json still matches the
+ * transcriptHash recorded in .meta.json. A mismatch (partial write, manual
+ * edit, tampering) yields null so the caller can report "conversation
+ * untouched" instead of rewinding onto unverified content.
+ */
+export declare function readSnapshotTranscript(cwd: string, id: string): Promise<unknown[] | null>;
 export declare function diff(cwd: string, id?: string): Promise<string>;
 export declare function undo(cwd: string, n?: number): Promise<void>;
 export declare function rewind(cwd: string): Promise<void>;

package/dist/checkpoints/store.js

@@ -97,6 +97,14 @@ export async function snapshot(cwd, files, opts) {
         meta.sessionId = opts.sessionId;
     if (opts?.eventId !== undefined)
         meta.eventId = opts.eventId;
+    if (opts?.transcript) {
+        const transcriptPath = path.join(dest, 'transcript.json');
+        await fs.writeFile(transcriptPath, JSON.stringify(opts.transcript), 'utf-8');
+        lockDown(transcriptPath, 0o600);
+        await fsyncFile(transcriptPath);
+        const hash = crypto.createHash('sha256').update(JSON.stringify(opts.transcript)).digest('hex');
+        meta.transcriptHash = hash;
+    }
     await fs.writeFile(metaTmp, JSON.stringify(meta, null, 2));
     lockDown(metaTmp, 0o600);
     await fsyncFile(metaTmp);
@@ -208,6 +216,35 @@ export async function snapshotFiles(cwd, id) {
         return [];
     }
 }
+/**
+ * Transcript captured at a checkpoint, or null when the snapshot predates
+ * transcript capture or the payload is missing/corrupt.
+ *
+ * The stored hash is verified on read: a checkpoint is only ever trusted for
+ * restoring the conversation when its transcript.json still matches the
+ * transcriptHash recorded in .meta.json. A mismatch (partial write, manual
+ * edit, tampering) yields null so the caller can report "conversation
+ * untouched" instead of rewinding onto unverified content.
+ */
+export async function readSnapshotTranscript(cwd, id) {
+    try {
+        const dir = path.join(ckptDir(cwd), id);
+        const meta = JSON.parse(await fs.readFile(path.join(dir, '.meta.json'), 'utf-8'));
+        const raw = await fs.readFile(path.join(dir, 'transcript.json'), 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return null;
+        if (typeof meta.transcriptHash === 'string') {
+            const actual = crypto.createHash('sha256').update(raw).digest('hex');
+            if (actual !== meta.transcriptHash)
+                return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
 export async function diff(cwd, id) {
     const ckpts = await listCheckpoints(cwd);
     const target = id ?? ckpts[ckpts.length - 1];
@@ -232,6 +269,8 @@ export async function undo(cwd, n = 1) {
     const metaRaw = await fs.readFile(path.join(srcDir, '.meta.json'), 'utf-8');
     const meta = JSON.parse(metaRaw);
     // Restore modified/created files to their snapshotted content…
+    // Transcript restore is handled by caller via transcript snapshot — read via
+    // readSnapshotTranscript() if the caller wants conversation rewind.
     for (const f of meta.files) {
         const src = containedPath(cwd, srcDir, f);
         const dest = src ? containedPath(cwd, cwd, f) : null;

package/dist/cli/repl.js

@@ -1261,6 +1261,20 @@ export async function startRepl(opts = {}) {
                     }
                     await undo(cwd, n);
                     let text = `Rewound to checkpoint ${n} (${target.id.slice(0, 12)}, ${target.files} file(s))`;
+                    // If transcript was captured for this checkpoint, restore it into the
+                    // active REPL session so /rewind full also reverts the conversation.
+                    const { readSnapshotTranscript } = await import('../checkpoints/store.js');
+                    const raw = await readSnapshotTranscript(cwd, target.id);
+                    // readSnapshotTranscript returns `unknown[]`; verify minimal Message shape
+                    // before giving it to adoptTranscript to avoid runtime type errors.
+                    const isMessage = (v) => !!v && typeof v === 'object' && 'role' in v && 'content' in v;
+                    if (Array.isArray(raw) && raw.length > 0 && raw.every(isMessage)) {
+                        sessionMessages = adoptTranscript(raw);
+                        text += '\nConversation restored from checkpoint transcript.';
+                    }
+                    else if (mode === 'full') {
+                        text += '\nConversation rewind skipped — no transcript captured for this checkpoint.';
+                    }
                     if (mode === 'summary' || mode === 'full') {
                         const files = before.split('\n').map((l) => l.trim()).filter(Boolean).slice(0, 20);
                         text += files.length > 0 ? `\nReverted working-tree changes:\n${files.map((f) => `  ${f}`).join('\n')}` : '\nWorking tree was clean before restore.';
@@ -2074,8 +2088,8 @@ export async function startRepl(opts = {}) {
                         queuedAppend({ id: `ckpt-${Date.now()}`, kind: 'text', text: 'Working tree clean — nothing to checkpoint.', role: 'assistant' });
                     }
                     else {
-                        const id = await snapshot(cwd, files.slice(0, 50));
-                        queuedAppend({ id: `ckpt2-${Date.now()}`, kind: 'text', text: `checkpoint ${String(id).slice(0, 8)} — ${files.length} file(s)`, role: 'assistant' });
+                        const id = await snapshot(cwd, files.slice(0, 50), { transcript: sessionMessages });
+                        queuedAppend({ id: `ckpt2-${Date.now()}`, kind: 'text', text: `checkpoint ${String(id).slice(0, 8)} — ${files.length} file(s)` + ` (conversation archived)`, role: 'assistant' });
                     }
                 }
                 catch (err) {

package/dist/tools/lsp/diagnostics.d.ts

@@ -49,3 +49,53 @@ export declare const lspGotoDefinitionTool: import("../types.js").Tool<{
     readonly candidates: number;
     readonly note?: undefined;
 }>;
+export declare const lspReferencesTool: import("../types.js").Tool<{
+    path: string;
+    line: number;
+    character?: number | undefined;
+}, {
+    readonly enabled: false;
+    readonly references: readonly [];
+    readonly note: "LSP off via KLYRO_LSP=0";
+} | {
+    readonly enabled: true;
+    readonly references: readonly [];
+    readonly note: `unreadable file: ${string}`;
+} | {
+    readonly enabled: true;
+    readonly references: readonly [];
+    readonly note: "no identifier under cursor";
+} | {
+    readonly enabled: true;
+    readonly references: {
+        file: string;
+        line: number;
+        kind: string;
+        name: string;
+    }[];
+    readonly note?: undefined;
+}>;
+export declare const lspOutlineTool: import("../types.js").Tool<{
+    path: string;
+}, {
+    readonly enabled: false;
+    readonly outline: readonly [];
+    readonly note: "LSP off via KLYRO_LSP=0";
+} | {
+    readonly enabled: true;
+    readonly outline: readonly [];
+    readonly note: `unreadable file: ${string}`;
+} | {
+    readonly enabled: true;
+    readonly outline: {
+        name: string;
+        kind: string;
+        line: number;
+        children: Array<{
+            name: string;
+            kind: string;
+            line: number;
+        }>;
+    }[];
+    readonly note?: undefined;
+}>;

package/dist/tools/lsp/diagnostics.js

@@ -5,8 +5,10 @@
  * project has one and filters the output to the requested path (or returns
  * a capped full-project list). Other languages report "unsupported".
  * `lsp_goto_definition` resolves the identifier under (line, character) to
- * its definition via the regex repo-map symbol index. Set KLYRO_LSP=0 to
- * force both tools off.
+ * its definition via the regex repo-map symbol index.
+ * `lsp_references` finds all references to the identifier under (line, character).
+ * `lsp_outline` returns a hierarchical symbol outline for a file.
+ * Set KLYRO_LSP=0 to force all tools off.
  */
 import { spawnSync } from 'node:child_process';
 import * as fs from 'node:fs/promises';
@@ -15,7 +17,7 @@ import { z } from 'zod';
 import { defineTool } from '../types.js';
 import { safe } from '../normalize.js';
 import { resolveWithinCwd } from '../../policy/path-guard.js';
-import { buildRepoMap } from '../../context/repo-map.js';
+import { buildRepoMap, extractSymbols } from '../../context/repo-map.js';
 function isOff() {
     return process.env.KLYRO_LSP === '0';
 }
@@ -104,3 +106,107 @@ export const lspGotoDefinitionTool = defineTool({
         return { enabled: true, location: best, candidates: hits.length };
     }),
 });
+export const lspReferencesTool = defineTool({
+    name: 'lsp_references',
+    description: 'Find all references to the identifier under (line, character) via the repo symbol index',
+    inputSchema: z.object({ path: z.string().min(1), line: z.number().int().min(1), character: z.number().int().min(0).optional() }),
+    permission: 'read',
+    isConcurrencySafe: true,
+    execute: async (input, ctx) => safe(async () => {
+        if (isOff())
+            return { enabled: false, references: [], note: 'LSP off via KLYRO_LSP=0' };
+        const { resolved } = resolveWithinCwd(ctx.cwd, input.path, ctx.agentAllowedPaths);
+        let content;
+        try {
+            content = await fs.readFile(resolved, 'utf-8');
+        }
+        catch {
+            return { enabled: true, references: [], note: `unreadable file: ${input.path}` };
+        }
+        const lines = content.split('\n');
+        const lineText = lines[input.line - 1] ?? '';
+        const col = Math.min(input.character ?? 0, lineText.length);
+        const wordAt = (() => {
+            const isWord = (c) => /[A-Za-z0-9_$]/.test(c);
+            let s = col;
+            let e = col;
+            while (s > 0 && isWord(lineText[s - 1]))
+                s--;
+            while (e < lineText.length && isWord(lineText[e]))
+                e++;
+            const w = lineText.slice(s, e);
+            return w || null;
+        })();
+        if (!wordAt)
+            return { enabled: true, references: [], note: 'no identifier under cursor' };
+        const files = await buildRepoMap({ cwd: ctx.cwd, maxFiles: 300 });
+        const refs = [];
+        const seen = new Set();
+        for (const f of files) {
+            for (const s of f.symbols) {
+                if (s.name === wordAt) {
+                    const key = `${f.path}:${s.line}:${s.name}`;
+                    if (!seen.has(key)) {
+                        seen.add(key);
+                        refs.push({ file: f.path, line: s.line, kind: s.kind, name: s.name });
+                    }
+                }
+            }
+        }
+        return { enabled: true, references: refs.slice(0, 100) };
+    }),
+});
+export const lspOutlineTool = defineTool({
+    name: 'lsp_outline',
+    description: 'Hierarchical symbol outline for a file via the repo symbol index',
+    inputSchema: z.object({ path: z.string().min(1) }),
+    permission: 'read',
+    isConcurrencySafe: true,
+    execute: async (input, ctx) => safe(async () => {
+        if (isOff())
+            return { enabled: false, outline: [], note: 'LSP off via KLYRO_LSP=0' };
+        const { resolved } = resolveWithinCwd(ctx.cwd, input.path, ctx.agentAllowedPaths);
+        // Symbol-extract this file directly rather than via buildRepoMap: the repo
+        // map is a whole-tree walk capped by maxFiles, so a single-file query can
+        // never be served from it (it would return whichever file the walk reached
+        // first, and the caller's path would usually be absent).
+        let content;
+        try {
+            content = await fs.readFile(resolved, 'utf-8');
+        }
+        catch {
+            return { enabled: true, outline: [], note: `unreadable file: ${input.path}` };
+        }
+        const symbols = extractSymbols(content, path.extname(resolved).toLowerCase());
+        // Build simple hierarchy: classes/interfaces as parents, methods/fields as children
+        const outline = [];
+        for (const sym of symbols) {
+            if (['class', 'interface', 'type'].includes(sym.kind)) {
+                outline.push({ name: sym.name, kind: sym.kind, line: sym.line, children: [] });
+            }
+        }
+        for (const sym of symbols) {
+            if (['method', 'function', 'property', 'field', 'const'].includes(sym.kind)) {
+                // Assign to the nearest preceding class/interface
+                let parentIdx = -1;
+                for (let i = outline.length - 1; i >= 0; i--) {
+                    const parent = outline[i];
+                    if (parent && parent.line < sym.line) {
+                        parentIdx = i;
+                        break;
+                    }
+                }
+                if (parentIdx >= 0) {
+                    const parentEntry = outline[parentIdx];
+                    if (parentEntry) {
+                        parentEntry.children.push({ name: sym.name, kind: sym.kind, line: sym.line });
+                    }
+                }
+                else {
+                    outline.push({ name: sym.name, kind: sym.kind, line: sym.line, children: [] });
+                }
+            }
+        }
+        return { enabled: true, outline };
+    }),
+});

package/dist/tools/registry.js

@@ -24,7 +24,7 @@ import { askUserTool } from './plan/ask-user.js';
 import { repoMapTool } from './repo-map.js';
 import { importsOfTool, importersOfTool } from './search/imports.js';
 import { findSymbolTool } from './symbols/find-symbol.js';
-import { lspDiagnosticsTool, lspGotoDefinitionTool } from './lsp/diagnostics.js';
+import { lspDiagnosticsTool, lspGotoDefinitionTool, lspReferencesTool, lspOutlineTool } from './lsp/diagnostics.js';
 import { expandResultTool } from './expand-result.js';
 import { memoryWriteTool } from './memory-write.js';
 import { webFetchTool } from './web/web-fetch.js';
@@ -117,6 +117,8 @@ export const builtinRegistry = () => {
     r.register(findSymbolTool);
     r.register(lspDiagnosticsTool);
     r.register(lspGotoDefinitionTool);
+    r.register(lspReferencesTool);
+    r.register(lspOutlineTool);
     r.register(expandResultTool);
     r.register(memoryWriteTool);
     r.register(webFetchTool);

package/package.json

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