kritya 0.8.2-beta

package/dist/repomap/symbols.js

@@ -0,0 +1,190 @@
+/**
+ * Language-aware symbol extraction for the repo map. Deliberately regex/
+ * heuristic-based rather than AST- or LSP-based: it must run over a whole
+ * repository in one pass, on any machine, with no language server to spawn and
+ * no native parser dependency. The result is a ctags-style skeleton — top-level
+ * (and lightly-nested) definitions with their signatures — not a precise parse.
+ * It is intended as a cheap map to orient the model, so the tradeoff favors
+ * breadth and speed over completeness: an occasional missed or spurious symbol
+ * is acceptable, a hung or crashed scan is not.
+ */
+/**
+ * File extension → language family. Covers the mainstream languages; a file
+ * whose extension isn't here is simply skipped by the map (graceful: no crash,
+ * no noise), rather than run through a generic pattern that produces junk.
+ */
+const EXT_FAMILY = {
+    ts: "js",
+    tsx: "js",
+    mts: "js",
+    cts: "js",
+    js: "js",
+    jsx: "js",
+    mjs: "js",
+    cjs: "js",
+    py: "python",
+    pyi: "python",
+    go: "go",
+    rs: "rust",
+    rb: "ruby",
+    php: "php",
+    java: "clike",
+    kt: "clike",
+    kts: "clike",
+    cs: "clike",
+    scala: "clike",
+    swift: "clike",
+    c: "clike",
+    h: "clike",
+    cpp: "clike",
+    cc: "clike",
+    cxx: "clike",
+    hpp: "clike",
+    hh: "clike",
+    hxx: "clike",
+    m: "clike",
+    mm: "clike",
+};
+/** Source extensions the map will scan (the keys of EXT_FAMILY). */
+export const CODE_EXTENSIONS = new Set(Object.keys(EXT_FAMILY));
+export function familyForExt(ext) {
+    return EXT_FAMILY[ext] ?? null;
+}
+/**
+ * Control-flow keywords that can precede `(...)` and otherwise look like a
+ * method definition (`if (x) {`, `for (…) {`). Used to reject false positives
+ * in the brace-language method heuristic.
+ */
+const CONTROL_KEYWORDS = new Set([
+    "if",
+    "for",
+    "while",
+    "switch",
+    "catch",
+    "return",
+    "do",
+    "else",
+    "case",
+    "with",
+    "await",
+    "when",
+    "elif",
+    "except",
+    "finally",
+    "match",
+    "using",
+    "lock",
+    "synchronized",
+]);
+/** Keyword-led definition patterns, matched against the trimmed line. */
+const PATTERNS = {
+    js: [
+        /^(?:export\s+)?(?:default\s+)?(?:declare\s+)?(?:abstract\s+)?class\s+[\w$]/,
+        /^(?:export\s+)?(?:declare\s+)?interface\s+[\w$]/,
+        /^(?:export\s+)?(?:declare\s+)?enum\s+[\w$]/,
+        /^(?:export\s+)?(?:declare\s+)?type\s+[\w$][^=]*=/,
+        /^(?:export\s+)?(?:default\s+)?(?:declare\s+)?(?:async\s+)?function\s*\*?\s*[\w$]/,
+        // arrow-function assigned to a binding: `export const foo = (…) => …`
+        /^(?:export\s+)?(?:declare\s+)?(?:const|let|var)\s+[\w$]+\s*(?::[^=]+)?=\s*(?:async\s*)?(?:\([^)]*\)|[\w$]+)\s*=>/,
+    ],
+    python: [/^(?:async\s+)?def\s+[\w]/, /^class\s+[\w]/],
+    go: [/^func\s+(?:\([^)]*\)\s*)?[\w]/, /^type\s+[\w]/],
+    rust: [
+        /^(?:pub(?:\([^)]*\))?\s+)?(?:default\s+)?(?:async\s+)?(?:unsafe\s+)?(?:const\s+)?fn\s+[\w]/,
+        /^(?:pub(?:\([^)]*\))?\s+)?(?:struct|enum|trait|union|mod|type)\s+[\w]/,
+        /^impl(?:\s|<)/,
+        /^macro_rules!\s+[\w]/,
+    ],
+    ruby: [/^(?:def|class|module)\s+[\w]/],
+    php: [
+        /^(?:abstract\s+|final\s+)?(?:public\s+|private\s+|protected\s+|static\s+)*function\s+[\w]/,
+        /^(?:abstract\s+|final\s+)?(?:class|interface|trait|enum)\s+[\w]/,
+    ],
+    clike: [
+        /^(?:(?:public|private|protected|internal|static|final|sealed|abstract|export|open|data)\s+)*(?:class|struct|enum|interface|namespace|record|union|protocol|object|module)\s+[\w]/,
+        // Kotlin `fun` / Swift `func`
+        /^(?:(?:public|private|protected|internal|static|final|open|override|suspend|operator|inline|external)\s+)*(?:fun|func)\s+[\w]/,
+    ],
+};
+/** Families whose class methods are detected by the brace heuristic below. */
+const BRACE_METHOD_FAMILIES = new Set(["js", "clike"]);
+/**
+ * Heuristic for a class/struct method written on a single line that opens its
+ * body with `{` — e.g. `async runTurn(text): Promise<void> {` or
+ * `public void foo(int x) {`. Requires the brace so a bare call (`foo();`) or a
+ * multi-line signature isn't mistaken for a definition, and rejects
+ * control-flow keywords (`if (x) {`).
+ */
+function isBraceMethod(trimmed) {
+    if (!trimmed.endsWith("{"))
+        return false;
+    if (trimmed.startsWith("}") || trimmed.startsWith("@"))
+        return false;
+    // A closing paren, an optional return type, then the opening brace.
+    if (!/\)\s*(?::\s*[^{]+|->\s*[^{]+)?\{$/.test(trimmed))
+        return false;
+    // The identifier immediately before the parameter list is the method name.
+    const m = trimmed.match(/([\w$~]+)\s*(?:<[^>]*>)?\s*\(/);
+    if (!m)
+        return false;
+    if (CONTROL_KEYWORDS.has(m[1]))
+        return false;
+    return true;
+}
+/** Strip the trailing body-opener (`{`, `{}`) or colon, collapse whitespace, and cap length. */
+function cleanSignature(trimmed) {
+    let s = trimmed
+        .replace(/\s*\{\s*\}?\s*$/, "")
+        .replace(/\s*[:;]\s*$/, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (s.length > 120)
+        s = s.slice(0, 119) + "…";
+    return s;
+}
+function leadingIndent(line) {
+    let indent = 0;
+    for (const ch of line) {
+        if (ch === " ")
+            indent++;
+        else if (ch === "\t")
+            indent += 2;
+        else
+            break;
+    }
+    return indent;
+}
+/**
+ * Extract up to `maxSymbols` definition signatures from a file's contents.
+ * Returns an empty array for files with no recognizable definitions (or an
+ * unsupported extension), which the caller drops from the map entirely.
+ */
+export function extractSymbols(content, ext, maxSymbols) {
+    const family = familyForExt(ext);
+    if (!family)
+        return [];
+    const patterns = PATTERNS[family];
+    const braceMethods = BRACE_METHOD_FAMILIES.has(family);
+    const out = [];
+    for (const raw of content.split("\n")) {
+        if (out.length >= maxSymbols)
+            break;
+        const trimmed = raw.trim();
+        if (!trimmed)
+            continue;
+        // Skip obvious comment lines (also guards `*` block-comment continuations).
+        if (trimmed.startsWith("//") ||
+            trimmed.startsWith("*") ||
+            trimmed.startsWith("/*") ||
+            trimmed.startsWith("#")) {
+            continue;
+        }
+        let matched = patterns.some((re) => re.test(trimmed));
+        if (!matched && braceMethods)
+            matched = isBraceMethod(trimmed);
+        if (!matched)
+            continue;
+        out.push({ indent: leadingIndent(raw), text: cleanSignature(trimmed) });
+    }
+    return out;
+}

package/dist/session/store.js

@@ -0,0 +1,328 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { writeFileAtomicSync } from "../atomicWrite.js";
+import { CONFIG_DIR } from "../config/config.js";
+import { hardenWindowsDir } from "../config/winAcl.js";
+import { debugLog } from "../config/debug.js";
+function sessionDir(workspace) {
+    const hash = crypto.createHash("sha1").update(workspace).digest("hex").slice(0, 12);
+    return path.join(CONFIG_DIR, "sessions", hash);
+}
+/**
+ * Transcripts can contain secrets that passed through tool output, so they are
+ * always written 0o600 rather than inheriting whatever mode the file had.
+ * writeFileAtomicSync is the shared implementation (see src/atomicWrite.ts):
+ * a sibling temp file renamed over the target, so a crash mid-write can never
+ * leave a half-written transcript behind.
+ */
+function writeSessionFile(filePath, data) {
+    writeFileAtomicSync(filePath, data, { mode: 0o600 });
+}
+/**
+ * Persists the conversation as one JSON message per line. A session maps to
+ * one file; --continue reloads the most recent file for the workspace.
+ */
+export class SessionStore {
+    ephemeral;
+    dir;
+    file;
+    /** When ephemeral, nothing is persisted to disk (used by subagents). */
+    constructor(workspace, ephemeral = false) {
+        this.ephemeral = ephemeral;
+        this.dir = sessionDir(workspace);
+        this.file = this.newFilePath();
+    }
+    newFilePath() {
+        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+        return path.join(this.dir, `${stamp}.jsonl`);
+    }
+    /**
+     * Stable identifier for this session (the transcript file's basename), used
+     * to correlate the audit log and telemetry spans with the session. Updates
+     * when the session rotates via reset(), so all three stay in lockstep.
+     */
+    get id() {
+        return path.basename(this.file, ".jsonl");
+    }
+    /**
+     * Absolute path of this session's transcript, or undefined when ephemeral
+     * (nothing is on disk). Used by the crash handler to tell the user where the
+     * conversation survives — a crash is exactly when that matters.
+     */
+    get path() {
+        return this.ephemeral ? undefined : this.file;
+    }
+    /** Path of the sidecar file that holds this session's task checklist. */
+    tasksFilePath() {
+        return SessionStore.tasksFilePathFor(this.file);
+    }
+    static tasksFilePathFor(sessionFile) {
+        return sessionFile.replace(/\.jsonl$/, ".tasks.json");
+    }
+    /**
+     * Persists the current task checklist alongside the session, so `-c`/`-r`
+     * can restore not just the conversation but what was done vs. pending.
+     * Best-effort, same as append() — never let this crash a turn.
+     */
+    saveTasks(tasks) {
+        if (this.ephemeral)
+            return;
+        try {
+            fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+            hardenWindowsDir(CONFIG_DIR);
+            if (!tasks.length) {
+                fs.rmSync(this.tasksFilePath(), { force: true });
+                return;
+            }
+            writeSessionFile(this.tasksFilePath(), JSON.stringify(tasks));
+        }
+        catch (err) {
+            debugLog(`SessionStore.saveTasks(${this.tasksFilePath()})`, err);
+        }
+    }
+    /** Loads the task checklist saved alongside a given session file, if any. */
+    static loadTasksForSession(sessionFile) {
+        try {
+            const raw = fs.readFileSync(SessionStore.tasksFilePathFor(sessionFile), "utf8");
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed))
+                return [];
+            return parsed.filter((t) => !!t &&
+                typeof t === "object" &&
+                typeof t.text === "string" &&
+                ["pending", "in_progress", "done"].includes(t.status));
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Begin a session, optionally seeded with resumed history. */
+    start(seed = []) {
+        if (this.ephemeral)
+            return;
+        // Session transcripts can contain secrets that passed through tool
+        // output — keep them readable only by the owner.
+        fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+        hardenWindowsDir(CONFIG_DIR);
+        if (seed.length) {
+            writeSessionFile(this.file, seed.map((m) => JSON.stringify(m) + "\n").join(""));
+        }
+    }
+    /**
+     * Appends one JSON-encoded message per call — a crash mid-write can only
+     * ever corrupt the single line currently being written, never anything
+     * appended before it (each prior line was already a completed, separate
+     * write). loadFile/matchesContent/listSessions all parse line-by-line and
+     * skip a line that fails JSON.parse, so a truncated last line loses at
+     * most that one message rather than the whole session.
+     */
+    append(message) {
+        if (this.ephemeral)
+            return;
+        try {
+            fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+            hardenWindowsDir(CONFIG_DIR);
+            fs.appendFileSync(this.file, JSON.stringify(message) + "\n", { mode: 0o600 });
+        }
+        catch (err) {
+            // Persistence is best-effort; never crash the session over it.
+            debugLog(`SessionStore.append(${this.file})`, err);
+        }
+    }
+    /** Start over with a fresh session file (used by /clear). */
+    rotate() {
+        this.file = this.newFilePath();
+    }
+    /**
+     * Rewrite the session file to hold exactly `messages`, atomically. The log
+     * is otherwise append-only; this is the one place it's rewound — used by
+     * /rewind to drop the messages after a checkpoint. The atomic write means a
+     * reader (e.g. a concurrent --continue) never sees a half-written file.
+     */
+    overwrite(messages) {
+        if (this.ephemeral)
+            return;
+        try {
+            fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+            hardenWindowsDir(CONFIG_DIR);
+            writeSessionFile(this.file, messages.map((m) => JSON.stringify(m) + "\n").join(""));
+        }
+        catch (err) {
+            // Persistence is best-effort; never crash the session over it.
+            debugLog(`SessionStore.overwrite(${this.file})`, err);
+        }
+    }
+    /**
+     * True if `filePath` is a real session transcript belonging to `workspace`
+     * — i.e. resolves inside that workspace's session directory. Callers that
+     * accept a session path from outside the process (e.g. the Electron
+     * renderer over IPC) must check this before loading it: without it,
+     * "load this session" is really "read any file the OS user can read".
+     */
+    static isSessionFile(workspace, filePath) {
+        const dir = sessionDir(workspace);
+        const resolved = path.resolve(dir, filePath);
+        const relative = path.relative(dir, resolved);
+        return (resolved.endsWith(".jsonl") &&
+            relative !== "" &&
+            !relative.startsWith("..") &&
+            !path.isAbsolute(relative));
+    }
+    static loadFile(filePath) {
+        const messages = [];
+        let raw;
+        try {
+            raw = fs.readFileSync(filePath, "utf8");
+        }
+        catch {
+            return messages;
+        }
+        for (const line of raw.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                messages.push(JSON.parse(line));
+            }
+            catch {
+                // Skip corrupt lines rather than failing the resume.
+            }
+        }
+        return messages;
+    }
+    /** Lines of a session file, one JSON message per non-blank line (unparsed). */
+    static readLines(filePath) {
+        let raw;
+        try {
+            raw = fs.readFileSync(filePath, "utf8");
+        }
+        catch {
+            return [];
+        }
+        return raw.split("\n").filter((line) => line.trim());
+    }
+    /** True if any message's content in the session file contains query (case-insensitive). Used for --resume search beyond the title preview. */
+    static matchesContent(filePath, query) {
+        if (!query.trim())
+            return true;
+        const needle = query.toLowerCase();
+        for (const line of SessionStore.readLines(filePath)) {
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (typeof message.content === "string" && message.content.toLowerCase().includes(needle)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Delete session files older than `retentionDays` across all workspaces.
+     * Best-effort. 0 or negative means "keep forever" — auto-delete is
+     * disabled rather than treated as an immediate-expiry retention window.
+     */
+    static cleanupOldSessions(retentionDays) {
+        if (retentionDays <= 0)
+            return;
+        const root = path.join(CONFIG_DIR, "sessions");
+        const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+        let dirs;
+        try {
+            dirs = fs.readdirSync(root);
+        }
+        catch {
+            return;
+        }
+        for (const d of dirs) {
+            const dir = path.join(root, d);
+            let files;
+            try {
+                files = fs.readdirSync(dir);
+            }
+            catch {
+                continue;
+            }
+            for (const f of files) {
+                if (!f.endsWith(".jsonl"))
+                    continue;
+                const file = path.join(dir, f);
+                try {
+                    if (fs.statSync(file).mtimeMs < cutoff) {
+                        fs.unlinkSync(file);
+                        fs.rmSync(SessionStore.tasksFilePathFor(file), { force: true });
+                    }
+                }
+                catch (err) {
+                    debugLog(`SessionStore.cleanupOldSessions(${file})`, err);
+                }
+            }
+        }
+    }
+    static loadLatest(workspace) {
+        const latest = SessionStore.listSessions(workspace)[0];
+        if (!latest)
+            return null;
+        const messages = SessionStore.loadFile(latest.file);
+        return messages.length ? messages : null;
+    }
+    /** The task checklist saved alongside the most recent session for `workspace`, if any. */
+    static loadLatestTasks(workspace) {
+        const latest = SessionStore.listSessions(workspace)[0];
+        return latest ? SessionStore.loadTasksForSession(latest.file) : [];
+    }
+    /** Sessions for a workspace, newest first, with a preview of the first user message. */
+    static listSessions(workspace) {
+        const dir = sessionDir(workspace);
+        let files;
+        try {
+            files = fs
+                .readdirSync(dir)
+                .filter((f) => f.endsWith(".jsonl"))
+                .sort()
+                .reverse();
+        }
+        catch {
+            return [];
+        }
+        const sessions = [];
+        for (const f of files.slice(0, 20)) {
+            const file = path.join(dir, f);
+            const lines = SessionStore.readLines(file);
+            if (!lines.length)
+                continue;
+            let cleaned = "";
+            for (const line of lines) {
+                let message;
+                try {
+                    message = JSON.parse(line);
+                }
+                catch {
+                    continue; // skip corrupt lines rather than failing the preview
+                }
+                if (message.role === "user" &&
+                    typeof message.content === "string" &&
+                    message.content.trim() &&
+                    !message.content.startsWith("[") // skip synthetic notes (undo, summaries)
+                ) {
+                    cleaned = message.content.replace(/\s+/g, " ").trim();
+                    break;
+                }
+            }
+            const preview = cleaned ? cleaned.slice(0, 60) : "(no preview)";
+            const title = cleaned ? cleaned.slice(0, 48) : "(untitled session)";
+            let date = "";
+            try {
+                date = fs.statSync(file).mtime.toLocaleString();
+            }
+            catch {
+                // leave empty
+            }
+            sessions.push({ file, date, preview, title, count: lines.length });
+        }
+        return sessions;
+    }
+}

package/dist/shell/background.js

@@ -0,0 +1,131 @@
+import { spawn } from "node:child_process";
+import os from "node:os";
+import { scrubbedShellEnv } from "../config/config.js";
+import { buildSandboxedCommand, requiresSandbox, sandboxUnavailableReason, shouldSandbox, } from "./sandbox.js";
+const MAX_BUFFER_CHARS = 50_000;
+/**
+ * Registry of long-running processes the agent started with shell
+ * background:true (dev servers, watchers). Captures a rolling tail of
+ * interleaved stdout/stderr; everything is killed when kritya exits.
+ */
+class BackgroundManager {
+    procs = new Map();
+    counter = 0;
+    start(command, cwd, sandboxMode) {
+        const id = `bg_${++this.counter}`;
+        const isWindows = os.platform() === "win32";
+        // detached on POSIX puts the command in its own process group, so kill()
+        // can signal the whole tree (shell + whatever it spawned), not just it.
+        // scrubbedShellEnv: background commands must not inherit provider API keys.
+        const spawnOpts = {
+            cwd,
+            env: scrubbedShellEnv(),
+            windowsHide: true,
+            detached: !isWindows,
+        };
+        let proc;
+        let cleanup;
+        if (shouldSandbox(sandboxMode, command)) {
+            const wrapped = buildSandboxedCommand(command, cwd);
+            if (wrapped) {
+                const opts = wrapped.env
+                    ? { ...spawnOpts, env: { ...spawnOpts.env, ...wrapped.env } }
+                    : spawnOpts;
+                proc = spawn(wrapped.cmd, wrapped.args, opts);
+                cleanup = wrapped.cleanup;
+            }
+            else if (requiresSandbox(sandboxMode)) {
+                // Same fail-closed contract as the foreground shell tool: "strict"
+                // means the sandbox is a hard requirement, so refuse rather than
+                // start an unconfined background process.
+                throw new Error(`sandboxExec is "strict" but sandboxing is unavailable here (${sandboxUnavailableReason()}) ` +
+                    `— refusing to start an unsandboxed background process`);
+            }
+            else {
+                // Sandboxing was requested but no sandbox binary is available here —
+                // fall back to a plain run, same as the foreground shell tool does.
+                proc = spawn(command, { ...spawnOpts, shell: true });
+            }
+        }
+        else {
+            // shell:true lets Node pick the right shell and quoting per OS from a
+            // single command string, same as the exec() used by the regular shell
+            // tool -- manually building a cmd.exe "/c" args array (the previous
+            // approach) mis-parses commands that themselves contain quotes.
+            proc = spawn(command, { ...spawnOpts, shell: true });
+        }
+        const entry = { proc, command, buffer: "", exitCode: null, running: true };
+        const append = (chunk) => {
+            entry.buffer += chunk.toString();
+            if (entry.buffer.length > MAX_BUFFER_CHARS) {
+                entry.buffer = entry.buffer.slice(-MAX_BUFFER_CHARS);
+            }
+        };
+        proc.stdout?.on("data", append);
+        proc.stderr?.on("data", append);
+        // "exit" (not "close"): grandchildren may inherit the pipes and keep them
+        // open after the direct child dies; exit still fires then.
+        proc.on("exit", (code) => {
+            entry.running = false;
+            entry.exitCode = code;
+            proc.stdout?.destroy();
+            proc.stderr?.destroy();
+            cleanup?.();
+        });
+        proc.on("error", (err) => {
+            entry.running = false;
+            entry.buffer += `\n[failed to start: ${err.message}]`;
+            // If the sandbox binary itself fails to spawn, "exit" may never fire, so
+            // the macOS temp profile would leak. cleanup is fs.rm({force:true}),
+            // which is idempotent, so running it from both handlers is safe.
+            cleanup?.();
+        });
+        this.procs.set(id, entry);
+        return { id };
+    }
+    signal(entry, sig) {
+        try {
+            if (os.platform() !== "win32" && entry.proc.pid) {
+                process.kill(-entry.proc.pid, sig); // whole process group
+            }
+            else {
+                entry.proc.kill(sig);
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    read(id) {
+        const entry = this.procs.get(id);
+        if (!entry)
+            return null;
+        return {
+            output: entry.buffer,
+            running: entry.running,
+            exitCode: entry.exitCode,
+            command: entry.command,
+        };
+    }
+    kill(id) {
+        const entry = this.procs.get(id);
+        if (!entry || !entry.running)
+            return false;
+        return this.signal(entry, "SIGTERM");
+    }
+    list() {
+        return [...this.procs.entries()].map(([id, e]) => ({
+            id,
+            command: e.command,
+            running: e.running,
+        }));
+    }
+    killAll() {
+        for (const entry of this.procs.values()) {
+            if (entry.running)
+                this.signal(entry, "SIGKILL");
+        }
+    }
+}
+export const backgroundManager = new BackgroundManager();