@cruxy/cli 0.1.0

package/dist/cli/repl.js

@@ -0,0 +1,114 @@
+import readline from "node:readline";
+import pc from "picocolors";
+import { logger } from "../utils/logger.js";
+import { createStreamPrinter } from "./stream-print.js";
+const PROMPT = `${pc.cyan("cruxy")} ${pc.dim("›")} `;
+const HELP = `Commands:
+  /help          show this help
+  /clear         clear the conversation history (keep the session)
+  /compact       summarize older history to free up context now
+  /reload        re-read project instructions (CRUXY.md)
+  /exit, /quit   leave cruxy
+  Ctrl+D         leave cruxy`;
+const defaultIO = () => ({
+    input: process.stdin,
+    output: process.stdout,
+});
+/**
+ * Read one line using a readline interface that is created and then **closed
+ * before this resolves**. This is the crux of the stdin coordination: while a
+ * turn runs (`session.send`), approvals grab stdin in raw mode via the Approver
+ * — so no readline interface may be live at that moment. Creating a fresh
+ * interface per line, and closing it the instant we have input, guarantees the
+ * two never contend.
+ *
+ * Resolves to the line, or `null` on EOF / Ctrl+D.
+ *
+ * The `answered` guard matters: `rl.close()` emits `'close'` **synchronously**,
+ * so the question callback's own close would otherwise fire the EOF path and
+ * clobber a perfectly good line with `null` — making every first line look like
+ * Ctrl+D. The guard ensures `'close'` only signals EOF when no line arrived.
+ */
+function readLine(io, prompt) {
+    const rl = readline.createInterface({
+        input: io.input,
+        output: io.output,
+    });
+    return new Promise((resolve) => {
+        let answered = false;
+        // Ctrl+D / EOF closes the interface without firing the question callback.
+        // Only treat it as EOF if no line was read (see the `answered` note above).
+        rl.on("close", () => {
+            if (!answered)
+                resolve(null);
+        });
+        rl.question(prompt, (answer) => {
+            answered = true;
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+/**
+ * Drive an interactive multi-turn session: prompt, read a line, dispatch slash
+ * commands or run a turn, repeat. Assistant text streams to stdout from within
+ * `session.send` (via the logger); this loop only owns input and control.
+ *
+ * `io` defaults to real stdin/stdout; tests inject a scripted stream pair.
+ */
+export async function runInteractive(session, io = defaultIO()) {
+    logger.print(pc.dim("interactive session — /help for commands, /exit or Ctrl+D to quit"));
+    for (;;) {
+        const line = await readLine(io, PROMPT);
+        // EOF / Ctrl+D.
+        if (line === null) {
+            logger.print(pc.dim("\nbye"));
+            return;
+        }
+        const trimmed = line.trim();
+        if (trimmed === "")
+            continue; // empty line → reprompt, no model call
+        if (trimmed === "/exit" || trimmed === "/quit") {
+            logger.print(pc.dim("bye"));
+            return;
+        }
+        if (trimmed === "/clear") {
+            session.clear();
+            logger.print(pc.dim("history cleared"));
+            continue;
+        }
+        if (trimmed === "/compact") {
+            try {
+                const n = await session.compact();
+                logger.print(pc.dim(n ? `compacted ${n} older messages` : "nothing to compact yet"));
+            }
+            catch (err) {
+                logger.error(err.message);
+            }
+            continue;
+        }
+        if (trimmed === "/reload") {
+            const loaded = session.reloadProjectInstructions();
+            logger.print(pc.dim(loaded
+                ? "reloaded project instructions (CRUXY.md)"
+                : "no project instructions found"));
+            continue;
+        }
+        if (trimmed === "/help") {
+            logger.print(HELP);
+            continue;
+        }
+        // A real turn. Assistant text streams to the output delta by delta through a
+        // single printer (which trims the model's leading blank lines); the agent
+        // loop closes the segment with one newline, so the next prompt lands on its
+        // own line. Errors (provider/API failures) log and return to the prompt
+        // rather than killing the REPL.
+        try {
+            const print = createStreamPrinter((text) => io.output.write(text));
+            await session.send(line, print);
+        }
+        catch (err) {
+            logger.error(err.message);
+        }
+    }
+}

package/dist/cli/stream-print.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Wrap a raw write sink into a printer for streamed assistant text.
+ *
+ * Models routinely begin a turn with one or more leading newlines; written
+ * verbatim those land as blank lines between the prompt and the answer. The
+ * printer drops the leading newline run of a turn (until the first visible
+ * character) so output starts on a single fresh line, and otherwise forwards
+ * text untouched — internal blank lines (markdown paragraphs, code) are
+ * preserved. State is per printer, so create one per turn.
+ *
+ * All turn output — the deltas and the loop's single segment-terminating
+ * newline — flows through this one sink, so nothing races the stream on stdout.
+ */
+export declare function createStreamPrinter(write: (text: string) => void): (delta: string) => void;

package/dist/cli/stream-print.js

@@ -0,0 +1,26 @@
+/**
+ * Wrap a raw write sink into a printer for streamed assistant text.
+ *
+ * Models routinely begin a turn with one or more leading newlines; written
+ * verbatim those land as blank lines between the prompt and the answer. The
+ * printer drops the leading newline run of a turn (until the first visible
+ * character) so output starts on a single fresh line, and otherwise forwards
+ * text untouched — internal blank lines (markdown paragraphs, code) are
+ * preserved. State is per printer, so create one per turn.
+ *
+ * All turn output — the deltas and the loop's single segment-terminating
+ * newline — flows through this one sink, so nothing races the stream on stdout.
+ */
+export function createStreamPrinter(write) {
+    let started = false;
+    return (delta) => {
+        let text = delta;
+        if (!started) {
+            text = text.replace(/^[\r\n]+/, "");
+            if (text === "")
+                return; // still inside the leading blank-line run
+            started = true;
+        }
+        write(text);
+    };
+}

package/dist/config/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./schema.js";
+export * from "./paths.js";
+export * from "./manager.js";
+export * from "./project.js";

package/dist/config/index.js

@@ -0,0 +1,4 @@
+export * from "./schema.js";
+export * from "./paths.js";
+export * from "./manager.js";
+export * from "./project.js";

package/dist/config/manager.d.ts

@@ -0,0 +1,34 @@
+import { type CruxyConfig } from "./schema.js";
+export interface LoadOptions {
+    /** Explicit config file, bypassing project discovery. */
+    configPath?: string;
+    /** Start dir for project-config discovery (defaults to cwd). */
+    cwd?: string;
+}
+export interface LoadedConfig {
+    config: CruxyConfig;
+    sources: {
+        global: string | null;
+        project: string | null;
+        explicit: string | null;
+    };
+}
+/**
+ * Resolution order (later wins):
+ *   schema defaults -> global file -> project file (or explicit) -> env vars
+ */
+export declare function loadConfig(opts?: LoadOptions): LoadedConfig;
+/** Resolve a dot-path (e.g. "model.temperature") against a config object. */
+export declare function getPath(obj: unknown, path: string): unknown;
+/**
+ * Set a dot-path on the given config file (creating it if needed), validating
+ * the full merged result before writing. Returns the written file path.
+ */
+export declare function setValue(path: string, rawValue: string, file: string): string;
+/** Write a default config to `file` if it does not already exist. */
+export declare function initConfig(file: string): {
+    path: string;
+    created: boolean;
+};
+/** Provider API key, read from the environment only (never persisted). */
+export declare function resolveApiKey(provider: string): string | undefined;

package/dist/config/manager.js

@@ -0,0 +1,151 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { CruxyConfigSchema } from "./schema.js";
+import { globalConfigPath, findProjectConfig } from "./paths.js";
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/** Deep-merge plain objects; later sources win. Arrays/scalars are replaced. */
+function deepMerge(base, override) {
+    const out = { ...base };
+    for (const [key, val] of Object.entries(override)) {
+        const prev = out[key];
+        if (isPlainObject(prev) && isPlainObject(val)) {
+            out[key] = deepMerge(prev, val);
+        }
+        else if (val !== undefined) {
+            out[key] = val;
+        }
+    }
+    return out;
+}
+function readJsonFile(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (!isPlainObject(parsed)) {
+            throw new Error(`config at ${path} must be a JSON object`);
+        }
+        return parsed;
+    }
+    catch (err) {
+        if (err instanceof SyntaxError) {
+            throw new Error(`config at ${path} is not valid JSON: ${err.message}`);
+        }
+        throw err;
+    }
+}
+/** Overrides sourced from environment variables. */
+function envOverrides() {
+    const out = {};
+    const model = {};
+    if (process.env.CRUXY_MODEL)
+        model.model = process.env.CRUXY_MODEL;
+    if (process.env.CRUXY_PROVIDER)
+        model.provider = process.env.CRUXY_PROVIDER;
+    if (Object.keys(model).length)
+        out.model = model;
+    if (process.env.CRUXY_LOG_LEVEL)
+        out.logLevel = process.env.CRUXY_LOG_LEVEL;
+    return out;
+}
+/**
+ * Resolution order (later wins):
+ *   schema defaults -> global file -> project file (or explicit) -> env vars
+ */
+export function loadConfig(opts = {}) {
+    const sources = {
+        global: null,
+        project: null,
+        explicit: null,
+    };
+    let merged = {};
+    const gPath = globalConfigPath();
+    if (existsSync(gPath)) {
+        merged = deepMerge(merged, readJsonFile(gPath));
+        sources.global = gPath;
+    }
+    if (opts.configPath) {
+        merged = deepMerge(merged, readJsonFile(opts.configPath));
+        sources.explicit = opts.configPath;
+    }
+    else {
+        const pPath = findProjectConfig(opts.cwd);
+        if (pPath) {
+            merged = deepMerge(merged, readJsonFile(pPath));
+            sources.project = pPath;
+        }
+    }
+    merged = deepMerge(merged, envOverrides());
+    const result = CruxyConfigSchema.safeParse(merged);
+    if (!result.success) {
+        const issues = result.error.issues
+            .map((i) => `  - ${i.path.join(".") || "(root)"}: ${i.message}`)
+            .join("\n");
+        throw new Error(`invalid configuration:\n${issues}`);
+    }
+    return { config: result.data, sources };
+}
+/** Resolve a dot-path (e.g. "model.temperature") against a config object. */
+export function getPath(obj, path) {
+    return path
+        .split(".")
+        .reduce((acc, key) => (isPlainObject(acc) ? acc[key] : undefined), obj);
+}
+/** Coerce a CLI string value to boolean/number where it parses cleanly. */
+function coerce(value) {
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    if (value !== "" && !Number.isNaN(Number(value)))
+        return Number(value);
+    return value;
+}
+/**
+ * Set a dot-path on the given config file (creating it if needed), validating
+ * the full merged result before writing. Returns the written file path.
+ */
+export function setValue(path, rawValue, file) {
+    const current = existsSync(file) ? readJsonFile(file) : {};
+    const keys = path.split(".");
+    let cursor = current;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const k = keys[i];
+        if (!isPlainObject(cursor[k]))
+            cursor[k] = {};
+        cursor = cursor[k];
+    }
+    cursor[keys[keys.length - 1]] = coerce(rawValue);
+    const check = CruxyConfigSchema.safeParse(current);
+    if (!check.success) {
+        const issues = check.error.issues
+            .map((i) => `  - ${i.path.join(".") || "(root)"}: ${i.message}`)
+            .join("\n");
+        throw new Error(`refusing to write invalid config:\n${issues}`);
+    }
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(current, null, 2) + "\n", "utf8");
+    return file;
+}
+/** Write a default config to `file` if it does not already exist. */
+export function initConfig(file) {
+    if (existsSync(file))
+        return { path: file, created: false };
+    mkdirSync(dirname(file), { recursive: true });
+    const defaults = CruxyConfigSchema.parse({});
+    writeFileSync(file, JSON.stringify(defaults, null, 2) + "\n", "utf8");
+    return { path: file, created: true };
+}
+/** Provider API key, read from the environment only (never persisted). */
+export function resolveApiKey(provider) {
+    switch (provider) {
+        case "cruxy":
+            return process.env.CRUXY_API_KEY;
+        case "anthropic":
+            return process.env.ANTHROPIC_API_KEY;
+        case "openai":
+            return process.env.OPENAI_API_KEY;
+        default:
+            return process.env.CRUXY_API_KEY;
+    }
+}

package/dist/config/paths.d.ts

@@ -0,0 +1,9 @@
+/** ~/.cruxy */
+export declare function globalDir(): string;
+/** ~/.cruxy/config.json */
+export declare function globalConfigPath(): string;
+/**
+ * Walk up from `startDir` looking for a project config file. Returns the first
+ * match, or null if none is found before the filesystem root.
+ */
+export declare function findProjectConfig(startDir?: string): string | null;

package/dist/config/paths.js

@@ -0,0 +1,31 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, parse } from "node:path";
+import { GLOBAL_DIR_NAME, CONFIG_FILE_NAME, PROJECT_CONFIG_FILENAMES, } from "../constants.js";
+/** ~/.cruxy */
+export function globalDir() {
+    return join(homedir(), GLOBAL_DIR_NAME);
+}
+/** ~/.cruxy/config.json */
+export function globalConfigPath() {
+    return join(globalDir(), CONFIG_FILE_NAME);
+}
+/**
+ * Walk up from `startDir` looking for a project config file. Returns the first
+ * match, or null if none is found before the filesystem root.
+ */
+export function findProjectConfig(startDir = process.cwd()) {
+    let dir = startDir;
+    const { root } = parse(dir);
+    while (true) {
+        for (const name of PROJECT_CONFIG_FILENAMES) {
+            const candidate = join(dir, name);
+            if (existsSync(candidate))
+                return candidate;
+        }
+        if (dir === root)
+            break;
+        dir = dirname(dir);
+    }
+    return null;
+}

package/dist/config/project.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Load project instructions from `cwd`: the first of CRUXY.md, then AGENTS.md
+ * that exists is read and returned. A missing (or unreadable) file is not an
+ * error — it simply yields `null`. Oversized files are truncated to `MAX_BYTES`
+ * with a trailing notice so they can't blow up the system prompt.
+ *
+ * Only `cwd` is consulted (no parent-directory walk) — instructions are scoped
+ * to the project you launched cruxy in.
+ */
+export declare function loadProjectInstructions(cwd: string): string | null;

package/dist/config/project.js

@@ -0,0 +1,36 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { PROJECT_INSTRUCTION_FILENAMES } from "../constants.js";
+/** Cap on instruction file size; the rest is dropped with a notice. */
+const MAX_BYTES = 32 * 1024;
+/**
+ * Load project instructions from `cwd`: the first of CRUXY.md, then AGENTS.md
+ * that exists is read and returned. A missing (or unreadable) file is not an
+ * error — it simply yields `null`. Oversized files are truncated to `MAX_BYTES`
+ * with a trailing notice so they can't blow up the system prompt.
+ *
+ * Only `cwd` is consulted (no parent-directory walk) — instructions are scoped
+ * to the project you launched cruxy in.
+ */
+export function loadProjectInstructions(cwd) {
+    for (const name of PROJECT_INSTRUCTION_FILENAMES) {
+        const file = join(cwd, name);
+        if (!existsSync(file))
+            continue;
+        let text;
+        try {
+            text = readFileSync(file, "utf8");
+        }
+        catch {
+            continue; // unreadable — treat as absent and try the next candidate
+        }
+        if (Buffer.byteLength(text, "utf8") > MAX_BYTES) {
+            const head = Buffer.from(text, "utf8")
+                .subarray(0, MAX_BYTES)
+                .toString("utf8");
+            return `${head}\n\n[truncated: ${name} exceeds ${MAX_BYTES} bytes]`;
+        }
+        return text;
+    }
+    return null;
+}