kritya 0.8.2-beta

package/dist/provider/switchyardSidecar.js

@@ -0,0 +1,245 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import http from "node:http";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { debugLog } from "../config/debug.js";
+/** The curated NVIDIA models this integration routes across. */
+export const SWITCHYARD_WEAK_MODEL = "nvidia/nemotron-3.5-lightning-30b-a3b";
+export const SWITCHYARD_STRONG_MODEL = "nvidia/nemotron-3-ultra-550b-a55b";
+/** Tried in order, direct against NVIDIA, if switchyard-server itself is unreachable or exhausts its own retries. */
+export const SWITCHYARD_FALLBACK_MODELS = [
+    "meta/muse-glimmer-30b",
+    "thinkingmachines/inkling",
+    "z-ai/glm-5.2",
+];
+/** The route id in the generated routes.toml — also the `model` field kritya sends. */
+export const SWITCHYARD_ROUTE_ID = "switchyard";
+/**
+ * Difficulty cutoff for `mode = "capability"`: the classifier scores each
+ * incoming request and anything above this goes to the strong tier. 0.5 is
+ * NVIDIA's own default — lower sends more traffic to the strong model.
+ *
+ * The sibling mode, `"escalation"`, is deliberately not used: it answers on
+ * the weak tier first and asks a judge whether that model is *stuck*, which
+ * is a signal about a spinning agent loop, not about a hard question. A
+ * difficult one-shot prompt that the weak model answers competently never
+ * trips it, so per-question routing has to classify the request up front.
+ */
+const SWITCHYARD_BASE_THRESHOLD = 0.5;
+const READY_TIMEOUT_MS = 10_000;
+/** Exported for tests; the sidecar startup path is the only real caller. */
+export function routesToml(nvidiaBaseUrl) {
+    return `schema_version = 1
+
+[llm_clients.nvidia]
+format = "openai_chat"
+base_url = "${nvidiaBaseUrl}"
+api_key_env = "NVIDIA_API_KEY"
+max_retries = 2
+
+[targets.weak]
+id = "${SWITCHYARD_WEAK_MODEL}"
+llm_client = "nvidia"
+
+[targets.strong]
+id = "${SWITCHYARD_STRONG_MODEL}"
+llm_client = "nvidia"
+
+[routes.${SWITCHYARD_ROUTE_ID}]
+id = "${SWITCHYARD_ROUTE_ID}"
+type = "llm_classifier"
+mode = "capability"
+classifier_target = "weak"
+strong_target = "strong"
+weak_target = "weak"
+base_threshold = ${SWITCHYARD_BASE_THRESHOLD}
+`;
+}
+/** Thrown when the switchyard-server binary can't be found or fails to come up. */
+export class SwitchyardUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SwitchyardUnavailableError";
+    }
+}
+/** Module-level singleton: one sidecar per kritya process, reused across
+ *  repeated `ensureSwitchyardSidecar` calls (e.g. /provider switching back
+ *  and forth) rather than spawning a new server each time. */
+let sidecar;
+function freePort() {
+    return new Promise((resolve, reject) => {
+        const srv = net.createServer();
+        srv.unref();
+        srv.on("error", reject);
+        srv.listen(0, "127.0.0.1", () => {
+            const addr = srv.address();
+            const port = typeof addr === "object" && addr ? addr.port : 0;
+            srv.close(() => resolve(port));
+        });
+    });
+}
+function waitForPort(port, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    return new Promise((resolve, reject) => {
+        const attempt = () => {
+            const sock = net.connect({ port, host: "127.0.0.1" }, () => {
+                sock.end();
+                resolve();
+            });
+            sock.on("error", () => {
+                sock.destroy();
+                if (Date.now() >= deadline) {
+                    reject(new SwitchyardUnavailableError(`switchyard-server did not start listening on port ${port} within ${timeoutMs}ms`));
+                }
+                else {
+                    setTimeout(attempt, 250);
+                }
+            });
+        };
+        attempt();
+    });
+}
+/**
+ * The TCP port can accept connections before switchyard-server's HTTP layer
+ * has finished wiring up routes internally — a socket that accepts and then
+ * hangs up (or resets) looks identical to "still starting" from here, so
+ * that's treated the same as connection-refused and retried. Any actual HTTP
+ * response, even an error status, proves the server is dispatching requests
+ * and is what a real chat request needs — this is deliberately not a chat
+ * completion itself, so it costs no tokens and doesn't depend on a specific
+ * route existing.
+ */
+function waitForHttpReady(port, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    return new Promise((resolve, reject) => {
+        const attempt = () => {
+            const req = http.get({ host: "127.0.0.1", port, path: "/v1/models", timeout: 2000 }, (res) => {
+                res.resume(); // drain so the socket can close
+                resolve();
+            });
+            req.on("timeout", () => req.destroy());
+            req.on("error", () => {
+                if (Date.now() >= deadline) {
+                    reject(new SwitchyardUnavailableError(`switchyard-server didn't respond to HTTP requests on port ${port} within ${timeoutMs}ms`));
+                }
+                else {
+                    setTimeout(attempt, 250);
+                }
+            });
+        };
+        attempt();
+    });
+}
+/**
+ * Start (or reuse) the local switchyard-server sidecar for this kritya
+ * process: writes a routes.toml scoped to the weak/strong tiers, launches
+ * the binary on a free localhost port, and waits for it to accept
+ * connections. Idempotent within a process.
+ */
+export async function ensureSwitchyardSidecar(nvidiaApiKey, nvidiaBaseUrl) {
+    if (!sidecar) {
+        sidecar = startSidecar(nvidiaApiKey, nvidiaBaseUrl).catch((err) => {
+            sidecar = undefined; // let the next call retry instead of caching the failure forever
+            throw err;
+        });
+    }
+    const handle = await sidecar;
+    return { baseUrl: handle.baseUrl };
+}
+async function startSidecar(nvidiaApiKey, nvidiaBaseUrl) {
+    const port = await freePort();
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "kritya-switchyard-"));
+    const configPath = path.join(dir, "routes.toml");
+    fs.writeFileSync(configPath, routesToml(nvidiaBaseUrl));
+    debugLog("switchyard-server", `config at ${configPath}, starting on 127.0.0.1:${port}`);
+    const proc = spawn("switchyard-server", ["--config", configPath, "--host", "127.0.0.1", "--port", String(port)], { env: { ...process.env, NVIDIA_API_KEY: nvidiaApiKey }, stdio: ["ignore", "pipe", "pipe"] });
+    proc.stdout?.on("data", (d) => debugLog("switchyard-server stdout", d.toString()));
+    proc.stderr?.on("data", (d) => debugLog("switchyard-server stderr", d.toString()));
+    const exited = new Promise((_, reject) => {
+        proc.once("error", (err) => {
+            if (err.code === "ENOENT") {
+                reject(new SwitchyardUnavailableError("switchyard-server not found on PATH. Install it with: cargo install --locked switchyard-server"));
+            }
+            else {
+                reject(err);
+            }
+        });
+        proc.once("exit", (code) => {
+            reject(new SwitchyardUnavailableError(`switchyard-server exited before it was ready (code ${code}). Run with KRITYA_DEBUG=1 to see its output.`));
+        });
+    });
+    exited.catch(() => { }); // observed via the race below; don't let the late rejection go unhandled
+    const readyDeadline = Date.now() + READY_TIMEOUT_MS;
+    await Promise.race([waitForPort(port, READY_TIMEOUT_MS), exited]);
+    await Promise.race([waitForHttpReady(port, Math.max(readyDeadline - Date.now(), 1000)), exited]);
+    debugLog("switchyard-server", `ready on 127.0.0.1:${port}`);
+    const cleanup = () => {
+        try {
+            proc.kill();
+        }
+        catch {
+            // already gone
+        }
+    };
+    process.once("exit", cleanup);
+    process.once("SIGINT", cleanup);
+    process.once("SIGTERM", cleanup);
+    return { baseUrl: `http://127.0.0.1:${port}/v1`, proc };
+}
+/**
+ * The single place every model-default chain (engine.ts, headless.ts,
+ * index.tsx, and the /provider switch in useAgent.ts) should go through.
+ * `SWITCHYARD_ROUTE_ID` is a routing directive, not a real model — it only
+ * means anything when switchyard is the active provider. Without this guard,
+ * it can end up carried over (via config.model, a --model flag left from a
+ * previous run, or /provider switching away) to a provider that has no idea
+ * what "switchyard" is and 404s on it. Candidates are tried in order; the
+ * first one that isn't empty and isn't a stale route id wins.
+ */
+export function resolveEffectiveModel(providerName, candidates, fallback) {
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        if (candidate === SWITCHYARD_ROUTE_ID && providerName !== "switchyard")
+            continue;
+        return candidate;
+    }
+    return fallback;
+}
+/**
+ * Warn when the model that just resolved for switchyard will silently bypass
+ * its routing this run. `/model` now persists per provider (see useAgent.ts)
+ * so this shouldn't arise from normal use going forward, but a legacy
+ * top-level `config.model` (saved before that fix, or hand-edited) can still
+ * win when `providers.switchyard.model` isn't set. `explicitModel` (a
+ * --model flag for this run) isn't flagged: that's a deliberate one-off, not
+ * a stale leftover.
+ */
+export function staleSwitchyardModelWarning(providerName, effectiveModel, explicitModel) {
+    if (providerName !== "switchyard" || explicitModel)
+        return undefined;
+    if (!effectiveModel || effectiveModel === SWITCHYARD_ROUTE_ID)
+        return undefined;
+    return (`⚠ Resolved model "${effectiveModel}" for switchyard, which bypasses its routing and calls ` +
+        `that model directly every turn. Run /model switchyard (or remove "model" from ` +
+        `~/.kritya/config.json) to restore routing.`);
+}
+/** Stop the sidecar, if one is running. Safe to call even if none was started. */
+export function stopSwitchyardSidecar() {
+    if (!sidecar)
+        return;
+    const started = sidecar;
+    sidecar = undefined;
+    started
+        .then((h) => {
+        try {
+            h.proc.kill();
+        }
+        catch {
+            // already gone
+        }
+    })
+        .catch(() => { });
+}

package/dist/provider/textToolCalls.js

@@ -0,0 +1,140 @@
+/**
+ * Recover tool calls a model wrote into its text instead of the tool-call
+ * channel.
+ *
+ * Every OpenAI-compatible provider is supposed to return tool calls as
+ * structured `tool_calls` deltas, and almost always does. But models do slip —
+ * mid-conversation, after a long tool chain — and emit the call as prose
+ * instead: a bare JSON object, often inside a code fence or a `<tool_call>`
+ * tag. Nothing downstream recognizes that, so the turn ends as if the model
+ * were done: the action never runs, and the user is shown a wall of raw JSON
+ * as the final answer. That is a silent, wrong-looking failure at exactly the
+ * moment the work was nearly finished.
+ *
+ * Recovery is deliberately narrow, because guessing wrong means running a tool
+ * the model never asked for:
+ *
+ *  - the text must be *entirely* the payload (after unwrapping one fence or
+ *    tag), so prose that merely quotes a tool call is left alone;
+ *  - it must parse as JSON;
+ *  - every call in it must name a tool that actually exists — one unknown name
+ *    and the whole recovery is abandoned rather than partly applied.
+ */
+/** Wrappers models put around a text-channel tool call. */
+const TAG_RE = /^<\s*(tool_call|toolcall|tool▁call|function_call|tool_use)\s*>([\s\S]*?)<\s*\/\s*\1\s*>$/i;
+/** Keys a model uses for the tool's name, and for its arguments. */
+const NAME_KEYS = ["name", "tool", "tool_name", "function", "recipient_name"];
+const ARG_KEYS = ["arguments", "parameters", "args", "input", "parameter", "tool_input"];
+/** Strip one layer of code fence and/or `<tool_call>`-style tag. */
+function unwrap(text) {
+    let body = text.trim();
+    for (let i = 0; i < 3; i++) {
+        const tagged = TAG_RE.exec(body);
+        if (tagged) {
+            body = tagged[2].trim();
+            continue;
+        }
+        if (body.startsWith("```")) {
+            // ```json\n{...}\n```  — the closing fence is sometimes missing when the
+            // model ran out of tokens, so it is optional.
+            const stripped = body
+                .replace(/^```[a-zA-Z0-9_-]*[ \t]*\r?\n?/, "")
+                .replace(/\r?\n?```$/, "")
+                .trim();
+            if (stripped === body)
+                break;
+            body = stripped;
+            continue;
+        }
+        // A trailing fence with no opening one — the shape seen when a model
+        // starts the JSON immediately but still closes the block.
+        if (body.endsWith("```")) {
+            body = body.slice(0, -3).trim();
+            continue;
+        }
+        break;
+    }
+    return body;
+}
+function asRecord(v) {
+    return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+/** Pull `{name, args}` out of one entry, in whichever shape the model used. */
+function toCall(entry, isKnown) {
+    const obj = asRecord(entry);
+    if (!obj)
+        return null;
+    // {"function": {"name": "...", "arguments": {...}}} — the OpenAI wire shape.
+    const fn = asRecord(obj.function);
+    if (fn && typeof fn.name === "string") {
+        return { name: fn.name, args: pickArgs(fn) };
+    }
+    // {"name": "write_file", "arguments": {...}} and its synonyms.
+    for (const key of NAME_KEYS) {
+        const value = obj[key];
+        if (typeof value === "string" && value.trim()) {
+            return { name: value.trim(), args: pickArgs(obj) };
+        }
+    }
+    // {"write_file": {...}} — the tool name as the only key.
+    const keys = Object.keys(obj);
+    if (keys.length === 1 && isKnown(keys[0])) {
+        return { name: keys[0], args: obj[keys[0]] };
+    }
+    return null;
+}
+function pickArgs(obj) {
+    for (const key of ARG_KEYS) {
+        if (key in obj)
+            return obj[key];
+    }
+    return {};
+}
+/** Arguments as the JSON string the rest of the pipeline expects. */
+function argsToJson(args) {
+    if (typeof args === "string") {
+        const trimmed = args.trim();
+        // Providers double-encode arguments as often as not; either is fine here,
+        // but a non-JSON string is not arguments at all.
+        try {
+            const parsed = JSON.parse(trimmed);
+            return asRecord(parsed) ? JSON.stringify(parsed) : "{}";
+        }
+        catch {
+            return "{}";
+        }
+    }
+    const record = asRecord(args);
+    return record ? JSON.stringify(record) : "{}";
+}
+export function recoverToolCalls(text, knownTools) {
+    if (!text.trim() || knownTools.size === 0)
+        return [];
+    const body = unwrap(text);
+    if (!body.startsWith("{") && !body.startsWith("["))
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return [];
+    }
+    const isKnown = (name) => knownTools.has(name);
+    const entries = Array.isArray(parsed) ? parsed : [parsed];
+    if (entries.length === 0)
+        return [];
+    const calls = [];
+    for (const [i, entry] of entries.entries()) {
+        const call = toCall(entry, isKnown);
+        // All or nothing: a payload we only partly understand is one we don't.
+        if (!call || !isKnown(call.name))
+            return [];
+        calls.push({
+            id: `recovered_${i}_${Date.now().toString(36)}`,
+            name: call.name,
+            argsJson: argsToJson(call.args),
+        });
+    }
+    return calls;
+}

package/dist/repomap/repoMap.js

@@ -0,0 +1,168 @@
+/**
+ * Repo map: a cheap, whole-repository structural skeleton fed to the model so
+ * it can orient itself in an unfamiliar or large codebase without reading every
+ * file. It lists source files ranked by importance, each with its definition
+ * signatures (from symbols.ts) but no bodies. This is the low-cost half of
+ * semantic codebase navigation — no embeddings, no index to keep in sync, no
+ * data leaving the machine — and covers the large majority of "where does X
+ * live" questions on its own. The model calls read_file for the actual bodies.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import fg from "fast-glob";
+import { isPathSafe, resolveSafe } from "../tools/common.js";
+import { loadIgnorePatterns } from "../tools/ignore.js";
+import { CODE_EXTENSIONS, extractSymbols } from "./symbols.js";
+const DEFAULTS = { maxFiles: 2000, maxOutputChars: 20_000, maxSymbolsPerFile: 40 };
+/** Skip files larger than this — generated bundles, vendored blobs, etc. */
+const MAX_FILE_BYTES = 512 * 1024;
+/** Directory segments that mark low-signal files: ranked down, never up. */
+const DEMOTE_SEGMENTS = new Set([
+    "test",
+    "tests",
+    "__tests__",
+    "spec",
+    "specs",
+    "fixtures",
+    "fixture",
+    "mocks",
+    "__mocks__",
+    "vendor",
+    "third_party",
+    "generated",
+    "gen",
+    "dist",
+    "build",
+    "out",
+    "examples",
+    "example",
+]);
+/** Directory segments that mark primary source: ranked up. */
+const PROMOTE_SEGMENTS = new Set(["src", "lib", "app", "pkg", "cmd", "internal", "core"]);
+/** Filenames (sans extension) that tend to be entry points: ranked up. */
+const ENTRYPOINT_NAMES = new Set(["index", "main", "mod", "lib", "app", "server", "cli", "init"]);
+function extname(rel) {
+    const dot = rel.lastIndexOf(".");
+    return dot === -1 ? "" : rel.slice(dot + 1).toLowerCase();
+}
+/**
+ * A path-only importance score, computed before reading any file so the
+ * `maxFiles` cap keeps the most relevant files on a huge repo. Higher is more
+ * important.
+ */
+function pathScore(rel) {
+    const segments = rel.split(/[\\/]/);
+    const name = segments[segments.length - 1];
+    const stem = name.slice(0, name.length - extname(name).length - 1);
+    let score = 0;
+    for (const seg of segments.slice(0, -1)) {
+        const lower = seg.toLowerCase();
+        if (DEMOTE_SEGMENTS.has(lower))
+            score -= 4;
+        if (PROMOTE_SEGMENTS.has(lower))
+            score += 3;
+    }
+    if (ENTRYPOINT_NAMES.has(stem.toLowerCase()))
+        score += 2;
+    if (/\.(min|bundle|generated|gen)\./i.test(name) || name.endsWith(".d.ts"))
+        score -= 4;
+    // Shallower files are usually more central; a gentle nudge, not a dominant term.
+    score -= (segments.length - 1) * 0.2;
+    return score;
+}
+/** Render one file's block: its path, then its indented signatures. */
+function renderFile(file) {
+    const minIndent = Math.min(...file.symbols.map((s) => s.indent));
+    const lines = file.symbols.map((s) => {
+        const level = Math.min(Math.round((s.indent - minIndent) / 2), 4);
+        return `${"  ".repeat(level + 1)}${s.text}`;
+    });
+    return `${file.rel.replaceAll("\\", "/")}\n${lines.join("\n")}`;
+}
+/**
+ * Build the repo map for `workspace` (optionally scoped to `subdir`). Returns a
+ * ready-to-show string; always bounded in size (never throws on a large repo —
+ * it caps files and output and reports what it omitted).
+ */
+export async function buildRepoMap(workspace, subdir = ".", options = {}) {
+    const opts = { ...DEFAULTS, ...options };
+    const root = resolveSafe(workspace, subdir || ".");
+    const scopeLabel = path.relative(workspace, root) || "(workspace root)";
+    const found = await fg("**/*", {
+        cwd: root,
+        dot: false,
+        onlyFiles: true,
+        followSymbolicLinks: false,
+        ignore: ["**/node_modules/**", "**/.git/**", ...loadIgnorePatterns(workspace)],
+        suppressErrors: true,
+    });
+    // Keep only source files, then rank by path so the maxFiles cap (which bounds
+    // how many files we actually read) retains the most important ones.
+    const candidates = found
+        .filter((f) => CODE_EXTENSIONS.has(extname(f)))
+        .map((f) => ({ rel: path.join(path.relative(workspace, root), f), local: f }))
+        .filter((c) => isPathSafe(workspace, path.join(root, c.local)))
+        .map((c) => ({ ...c, ps: pathScore(c.rel) }))
+        .sort((a, b) => b.ps - a.ps);
+    const totalSource = candidates.length;
+    const scanned = candidates.slice(0, opts.maxFiles);
+    const mapped = [];
+    for (const c of scanned) {
+        const abs = path.join(root, c.local);
+        let stat;
+        try {
+            stat = await fs.stat(abs);
+        }
+        catch {
+            continue;
+        }
+        if (stat.size > MAX_FILE_BYTES)
+            continue;
+        let content;
+        try {
+            content = await fs.readFile(abs, "utf8");
+        }
+        catch {
+            continue;
+        }
+        if (content.slice(0, 8000).includes("\0"))
+            continue;
+        const symbols = extractSymbols(content, extname(c.local), opts.maxSymbolsPerFile);
+        if (!symbols.length)
+            continue;
+        // Final score blends the path score with a modest bonus for structural
+        // density, so a central file full of definitions sorts above a stub.
+        const score = c.ps + Math.min(symbols.length, 20) * 0.25;
+        mapped.push({ rel: c.rel, symbols, score });
+    }
+    if (!mapped.length) {
+        const reason = totalSource === 0
+            ? "no source files found"
+            : "no definitions were extracted (unsupported languages, or files without top-level definitions)";
+        return `Repo map for ${scopeLabel}: ${reason}. Use glob/grep to explore instead.`;
+    }
+    mapped.sort((a, b) => b.score - a.score);
+    const header = `Repo map for ${scopeLabel} — structural skeleton (definition signatures only, no bodies). ` +
+        `Ranked by importance; call read_file for full code.`;
+    const blocks = [];
+    let used = header.length;
+    let shown = 0;
+    for (const file of mapped) {
+        const block = renderFile(file);
+        if (shown > 0 && used + block.length + 2 > opts.maxOutputChars)
+            break;
+        blocks.push(block);
+        used += block.length + 2;
+        shown++;
+    }
+    const omitted = mapped.length - shown;
+    const cappedNote = totalSource > scanned.length
+        ? ` ${totalSource - scanned.length} lower-ranked file(s) were not scanned.`
+        : "";
+    const footer = omitted > 0
+        ? `\n\n… ${omitted} more mapped file(s) not shown (output limit). Re-run repo_map with a path to focus, or use grep/read_file.${cappedNote}`
+        : cappedNote
+            ? `\n${cappedNote.trim()}`
+            : "";
+    return `${header} Showing ${shown} of ${mapped.length} file(s).\n\n${blocks.join("\n\n")}${footer}`;
+}