@arnilo/prism 0.0.1

package/dist/cli-runner.js

@@ -0,0 +1,167 @@
+import { createAgent, createMockProvider, providerDone, providerTextDelta } from "./index.js";
+import { runRpcServer } from "./rpc.js";
+export const usage = `Usage: prism [--mode print|json|rpc] [-p prompt] [options]
+
+Options:
+  -p, --prompt <text>        Prompt to run in print/json mode
+  --provider <name>          Explicit provider id (mock is built in for smoke tests)
+  --model <name>             Explicit model name
+  --session <id>             Session id
+  --config <path>            Explicit config path (recorded, not auto-loaded)
+  --resource <uri>           Explicit resource URI (recorded, not auto-loaded)
+  --extension <name>         Explicit extension name (recorded, not auto-loaded)
+  --tool <name>              Explicit tool name (recorded, not auto-enabled)
+  --system <text>            System instructions
+  --context <text>           Context text
+  --compact <entries>        Auto-compaction threshold
+  --max-tool-rounds <n>      Maximum tool rounds
+  -h, --help                 Show this help
+`;
+const valueFlags = new Set(["--prompt", "--mode", "--provider", "--model", "--session", "--config", "--resource", "--extension", "--tool", "--system", "--context", "--compact", "--max-tool-rounds"]);
+export function parseCliArgs(argv) {
+    let mode = "print";
+    let prompt;
+    let provider;
+    let model;
+    let session;
+    let system;
+    let compact;
+    let maxToolRounds;
+    let help = false;
+    const config = [];
+    const resources = [];
+    const extensions = [];
+    const tools = [];
+    const context = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const flag = argv[i];
+        if (flag === "-h" || flag === "--help") {
+            help = true;
+            continue;
+        }
+        const name = flag === "-p" ? "--prompt" : flag;
+        if (!valueFlags.has(name))
+            throw new CliUsageError(`Unknown flag: ${flag}`);
+        const value = argv[i + 1];
+        if (value === undefined || value.startsWith("--"))
+            throw new CliUsageError(`Missing value for ${flag}`);
+        i += 1;
+        switch (name) {
+            case "--prompt":
+                prompt = value;
+                break;
+            case "--mode":
+                if (value !== "print" && value !== "json" && value !== "rpc")
+                    throw new CliUsageError(`Invalid mode: ${value}`);
+                mode = value;
+                break;
+            case "--provider":
+                provider = value;
+                break;
+            case "--model":
+                model = value;
+                break;
+            case "--session":
+                session = value;
+                break;
+            case "--config":
+                config.push(value);
+                break;
+            case "--resource":
+                resources.push(value);
+                break;
+            case "--extension":
+                extensions.push(value);
+                break;
+            case "--tool":
+                tools.push(value);
+                break;
+            case "--system":
+                system = value;
+                break;
+            case "--context":
+                context.push(value);
+                break;
+            case "--compact":
+                compact = positiveInt(value, flag);
+                break;
+            case "--max-tool-rounds":
+                maxToolRounds = positiveInt(value, flag);
+                break;
+        }
+    }
+    return { mode, prompt, provider, model, session, config, resources, extensions, tools, system, context, compact, maxToolRounds, help };
+}
+export async function runCli(argv, runtime) {
+    let options;
+    try {
+        options = parseCliArgs(argv);
+    }
+    catch (error) {
+        write(runtime.stderr, `${error instanceof Error ? error.message : String(error)}\n${usage}`);
+        return 2;
+    }
+    if (options.help) {
+        write(runtime.stdout, usage);
+        return 0;
+    }
+    try {
+        if (options.mode === "rpc") {
+            await runRpcServer({ stdin: runtime.stdin, stdout: runtime.stdout, createSession: (id) => (runtime.createSession ?? defaultCreateSession)({ ...options, session: id ?? options.session }), commands: runtime.commands });
+            return 0;
+        }
+        if (!options.prompt)
+            throw new CliUsageError("Missing prompt: use -p or --prompt");
+        const session = (runtime.createSession ?? defaultCreateSession)(options);
+        await runPromptMode(session, options, runtime.stdout, options.mode);
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (error instanceof CliUsageError) {
+            write(runtime.stderr, `${message}\n${usage}`);
+            return 2;
+        }
+        if (options.mode === "json")
+            write(runtime.stdout, `${JSON.stringify({ type: "error", error: { message } })}\n`);
+        else
+            write(runtime.stderr, `${message}\n`);
+        return 1;
+    }
+}
+export async function runPromptMode(session, options, stdout, mode) {
+    const events = (async () => {
+        for await (const event of session.subscribe()) {
+            if (mode === "json")
+                write(stdout, `${JSON.stringify({ type: "event", sessionId: event.sessionId, runId: "runId" in event ? event.runId : undefined, event })}\n`);
+            else if (event.type === "message_delta" && event.content.type === "text")
+                write(stdout, event.content.text);
+        }
+    })();
+    await session.run(options.prompt ?? "", runOptions(options));
+    await events;
+}
+export class CliUsageError extends Error {
+}
+function defaultCreateSession(options) {
+    if (options.provider !== "mock")
+        throw new CliUsageError("No provider configured. Pass --provider mock for a smoke test or embed Prism with an explicit provider.");
+    const model = { provider: "mock", model: options.model ?? "mock" };
+    return createAgent({ model, provider: createMockProvider([providerTextDelta("Hello"), providerDone()]), instructions: options.system }).createSession({ id: options.session });
+}
+function runOptions(options) {
+    return {
+        maxToolRounds: options.maxToolRounds,
+        compaction: options.compact ? { thresholdEntries: options.compact } : undefined,
+    };
+}
+function positiveInt(value, flag) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0)
+        throw new CliUsageError(`Invalid value for ${flag}: ${value}`);
+    return parsed;
+}
+function write(stream, text) {
+    stream.write(text);
+}
+//# sourceMappingURL=cli-runner.js.map

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { runCli } from "./cli-runner.js";
+const code = await runCli(process.argv.slice(2), {
+    stdin: process.stdin,
+    stdout: process.stdout,
+    stderr: process.stderr,
+});
+process.exitCode = code;
+//# sourceMappingURL=cli.js.map

package/dist/compaction.d.ts

@@ -0,0 +1,9 @@
+import type { CompactionEntryData, CompactionStrategy } from "./contracts.js";
+export interface DefaultCompactionStrategyOptions {
+    readonly name?: string;
+    readonly keepRecentEntries?: number;
+    readonly maxSummaryChars?: number;
+    readonly secrets?: readonly (string | undefined)[];
+}
+export declare function createDefaultCompactionStrategy(options?: DefaultCompactionStrategyOptions): CompactionStrategy;
+export declare function isCompactionEntryData(value: unknown): value is CompactionEntryData;

package/dist/compaction.js

@@ -0,0 +1,67 @@
+import { redactSecrets } from "./redaction.js";
+import { createSessionEntry } from "./session-stores.js";
+export function createDefaultCompactionStrategy(options = {}) {
+    const name = options.name ?? "default-compaction";
+    return {
+        name,
+        compact(context) {
+            const keepRecentEntries = Math.max(0, context.keepRecentEntries ?? options.keepRecentEntries ?? 8);
+            const maxSummaryChars = Math.max(0, options.maxSummaryChars ?? 4000);
+            const messages = context.entries.filter((entry) => entry.kind === "message" && entry.message);
+            const keepEntryIds = keepRecentEntries === 0 ? [] : messages.slice(-keepRecentEntries).map((entry) => entry.id);
+            const firstKept = keepEntryIds[0];
+            const firstKeptIndex = firstKept ? context.entries.findIndex((entry) => entry.id === firstKept) : context.entries.length;
+            const oldEntries = context.entries.slice(0, firstKeptIndex < 0 ? context.entries.length : firstKeptIndex);
+            const throughEntryId = oldEntries.at(-1)?.id;
+            const summary = truncate(redactSecrets(summarize(oldEntries), [...(options.secrets ?? []), ...(context.secrets ?? [])]), maxSummaryChars);
+            const data = { throughEntryId, keepEntryIds, strategy: name, trigger: context.trigger };
+            const parentId = context.entries.at(-1)?.id;
+            return {
+                summary,
+                entries: [createSessionEntry({ sessionId: context.sessionId, parentId, kind: "compaction", summary, data })],
+            };
+        },
+    };
+}
+export function isCompactionEntryData(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const data = value;
+    return (data.throughEntryId === undefined || typeof data.throughEntryId === "string")
+        && (data.keepEntryIds === undefined || (Array.isArray(data.keepEntryIds) && data.keepEntryIds.every((item) => typeof item === "string")))
+        && (data.strategy === undefined || typeof data.strategy === "string")
+        && (data.trigger === undefined || typeof data.trigger === "string");
+}
+function summarize(entries) {
+    const lines = entries.flatMap((entry) => entryText(entry));
+    return lines.length ? lines.join("\n") : "No older session entries to summarize.";
+}
+function entryText(entry) {
+    if (entry.kind === "message" && entry.message)
+        return [`${entry.message.role}: ${messageText(entry.message)}`];
+    if (entry.kind === "summary" && entry.summary)
+        return [`summary: ${entry.summary}`];
+    if (entry.kind === "model_change" && entry.model)
+        return [`model changed to ${entry.model.provider}/${entry.model.model}`];
+    if (entry.kind === "label" && entry.label)
+        return [`label: ${entry.label}`];
+    return [];
+}
+function messageText(message) {
+    return message.content.map(blockText).filter(Boolean).join(" ");
+}
+function blockText(block) {
+    if (block.type === "text" || block.type === "thinking")
+        return block.text;
+    if (block.type === "tool_call")
+        return `[tool_call ${block.name}]`;
+    if (block.type === "tool_result")
+        return `[tool_result ${block.name}]`;
+    return "[image]";
+}
+function truncate(text, max) {
+    if (max === 0 || text.length <= max)
+        return text;
+    return `${text.slice(0, Math.max(0, max - 1))}…`;
+}
+//# sourceMappingURL=compaction.js.map

package/dist/config.d.ts

@@ -0,0 +1,17 @@
+import type { JsonObject } from "./contracts.js";
+export interface ConfigLoadContext {
+    readonly signal?: AbortSignal;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface ConfigProvider {
+    readonly name: string;
+    load(context?: ConfigLoadContext): Promise<JsonObject | undefined> | JsonObject | undefined;
+}
+export interface ConfigLayer {
+    readonly name: string;
+    readonly config: JsonObject;
+}
+export declare function isJsonObject(value: unknown): value is JsonObject;
+export declare function assertJsonObject(value: unknown, label?: string): asserts value is JsonObject;
+export declare function loadConfigLayers(providers: readonly ConfigProvider[], context?: ConfigLoadContext): Promise<ConfigLayer[]>;
+export declare function mergeConfigLayers(layers: readonly ConfigLayer[]): JsonObject;

package/dist/config.js

@@ -0,0 +1,69 @@
+export function isJsonObject(value) {
+    return isPlainObject(value) && isJsonValue(value);
+}
+export function assertJsonObject(value, label = "value") {
+    if (!isJsonObject(value))
+        throw new Error(`${label} must be a JSON object`);
+}
+export async function loadConfigLayers(providers, context) {
+    const layers = [];
+    for (const provider of providers) {
+        const config = await provider.load(context);
+        if (config !== undefined) {
+            assertJsonObject(config, `config provider ${provider.name}`);
+            layers.push({ name: provider.name, config });
+        }
+    }
+    return layers;
+}
+export function mergeConfigLayers(layers) {
+    let merged = {};
+    for (const layer of layers) {
+        assertJsonObject(layer.config, `config layer ${layer.name}`);
+        merged = mergeObjects(merged, layer.config);
+    }
+    return merged;
+}
+function mergeObjects(base, override) {
+    const result = { ...cloneJsonObject(base) };
+    for (const [key, value] of Object.entries(override)) {
+        const current = result[key];
+        result[key] = isPlainObject(current) && isPlainObject(value)
+            ? mergeObjects(current, value)
+            : cloneJsonValue(value);
+    }
+    return result;
+}
+function cloneJsonObject(value) {
+    const result = {};
+    for (const [key, entry] of Object.entries(value))
+        result[key] = cloneJsonValue(entry);
+    return result;
+}
+function cloneJsonValue(value) {
+    if (Array.isArray(value))
+        return value.map(cloneJsonValue);
+    if (isPlainObject(value))
+        return cloneJsonObject(value);
+    return value;
+}
+function isJsonValue(value) {
+    if (value === null)
+        return true;
+    if (typeof value === "string" || typeof value === "boolean")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    if (isPlainObject(value))
+        return Object.values(value).every(isJsonValue);
+    return false;
+}
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+//# sourceMappingURL=config.js.map