@arnilo/prism 0.0.1 → 0.0.2

package/dist/cli-runner.d.ts

@@ -1,5 +1,6 @@
 import type { Readable, Writable } from "node:stream";
-import type { AgentSession } from "./contracts.js";
+import type { AgentSession, ContributionFileKind, InstructionInjector, Skill, SystemPromptContribution } from "./contracts.js";
+import type { AgentBundle } from "./node/agent-definitions.js";
 import { type RpcSessionFactory } from "./rpc.js";
 export type CliMode = "print" | "json" | "rpc";
 export interface CliOptions {
@@ -17,6 +18,36 @@ export interface CliOptions {
     readonly compact?: number;
     readonly maxToolRounds?: number;
     readonly help: boolean;
+    readonly discover: boolean;
+    readonly discoverKinds: readonly ContributionFileKind[];
+    readonly noDiscovery: boolean;
+    /** Parsed flag: `--agents-config <path>` points at the app config root holding
+     *  `agents/<name>/AGENT.md` bundles. Opt-in; default runs never scan it. */
+    readonly agentsConfig?: string;
+    /** Runtime-populated (not a parsed flag): agent bundles discovered by `--agents-config`
+     *  via {@link discoverAgentBundles}. Host-owned resolution. */
+    readonly discoveredAgents: readonly AgentBundle[];
+    /** Runtime-populated (not a parsed flag): skills discovered by `--discover`,
+     *  threaded into `createSession` so the bootstrap can build a SkillRegistry. */
+    readonly discoveredSkills: readonly Skill[];
+    /** Runtime-populated (not a parsed flag): instruction injectors discovered by
+     *  `--discover`, selectable by name via `--instruction` (Task 8). */
+    readonly discoveredInjectors: readonly InstructionInjector[];
+    /** Parsed flag: `--instruction <name>` (repeatable). `false` disables injectors. */
+    readonly instructions: readonly string[];
+    /** Parsed flag: `--injector-file <path>` (repeatable); markdown → static injector. */
+    readonly injectorFiles: readonly string[];
+    /** Runtime-populated: `--instruction`/`--injector-file` resolved to live injectors. */
+    readonly resolvedInstructionInjectors: readonly InstructionInjector[];
+    /** Parsed flag: `--no-agents-md` / `--no-system-md` skip the corresponding auto-load. */
+    readonly noAgentsMd: boolean;
+    readonly noSystemMd: boolean;
+    /** Parsed flag: `--agents-md-file <path>` / `--system-md-file <path>` override read paths. */
+    readonly agentsMdFile?: string;
+    readonly systemMdFile?: string;
+    /** Runtime-populated: AGENTS.md/SYSTEM.md layers loaded from disk (print/json modes only;
+    *  RPC is host-owned). Threaded into `AgentConfig.systemPrompt` by `defaultCreateSession`. */
+    readonly systemPromptLayers: readonly SystemPromptContribution[];
 }
 export interface CliRuntime {
     readonly stdin: Readable;
@@ -24,8 +55,13 @@ export interface CliRuntime {
     readonly stderr: Writable;
     readonly createSession?: (options: CliOptions) => AgentSession;
     readonly commands?: RpcSessionFactory["commands"];
+    /** Workspace root for `--discover`. Defaults to `process.cwd()`. */
+    readonly workspaceRoot?: string;
+    /** Optional global root for SYSTEM.md auto-load (host-controlled). No default;
+     *  the CLI does not auto-touch the user's home directory. */
+    readonly globalRoot?: string;
 }
-export declare const usage = "Usage: prism [--mode print|json|rpc] [-p prompt] [options]\n\nOptions:\n  -p, --prompt <text>        Prompt to run in print/json mode\n  --provider <name>          Explicit provider id (mock is built in for smoke tests)\n  --model <name>             Explicit model name\n  --session <id>             Session id\n  --config <path>            Explicit config path (recorded, not auto-loaded)\n  --resource <uri>           Explicit resource URI (recorded, not auto-loaded)\n  --extension <name>         Explicit extension name (recorded, not auto-loaded)\n  --tool <name>              Explicit tool name (recorded, not auto-enabled)\n  --system <text>            System instructions\n  --context <text>           Context text\n  --compact <entries>        Auto-compaction threshold\n  --max-tool-rounds <n>      Maximum tool rounds\n  -h, --help                 Show this help\n";
+export declare const usage = "Usage: prism [--mode print|json|rpc] [-p prompt] [options]\n\nOptions:\n  -p, --prompt <text>        Prompt to run in print/json mode\n  --provider <name>          Explicit provider id (mock is built in for smoke tests)\n  --model <name>             Explicit model name\n  --session <id>             Session id\n  --config <path>            Explicit config path (recorded, not auto-loaded)\n  --resource <uri>           Explicit resource URI (recorded, not auto-loaded)\n  --extension <name>         Explicit extension name (recorded, not auto-loaded)\n  --tool <name>              Explicit tool name (recorded, not auto-enabled)\n  --system <text>            System instructions\n  --context <text>           Context text\n  --compact <entries>        Auto-compaction threshold\n  --max-tool-rounds <n>      Maximum tool rounds\n  --discover                 Enable workspace contribution discovery (opt-in)\n  --discover-kinds <csv>     Kinds to discover (default: skill; skill,tool,context,instructions)\n  --no-discovery             Disable discovery even if --discover is set\n  --agents-config <path>     App config root holding agents/<name>/AGENT.md bundles (opt-in)\n  --no-agents-md             Skip auto-loading <workspaceRoot>/AGENTS.md\n  --no-system-md             Skip auto-loading the global SYSTEM.md layer\n  --agents-md-file <path>    Read AGENTS.md from <path> instead (trust-gated, source: app)\n  --system-md-file <path>    Read SYSTEM.md from <path> instead (source: user)\n  -h, --help                 Show this help\n";
 export declare function parseCliArgs(argv: readonly string[]): CliOptions;
 export declare function runCli(argv: readonly string[], runtime: CliRuntime): Promise<number>;
 export declare function runPromptMode(session: AgentSession, options: CliOptions, stdout: Writable, mode: "print" | "json"): Promise<void>;

package/dist/cli-runner.js

@@ -1,4 +1,14 @@
-import { createAgent, createMockProvider, providerDone, providerTextDelta } from "./index.js";
+import process from "node:process";
+import { createAgent, createMockProvider, providerDone, providerTextDelta, resolveInstructionInjectors, createContributionRegistry } from "./index.js";
+import { readFile } from "node:fs/promises";
+import { basename, dirname } from "node:path";
+import { createContributionRegistries, registerDiscoveredContributions } from "./contributions.js";
+import { createSkillRegistry } from "./skills.js";
+import { discoverContributions } from "./node/contribution-discovery.js";
+import { discoverAgentBundles } from "./node/agent-definitions.js";
+import { registerDiscoveredInstructionInjectors } from "./node/instruction-injectors.js";
+import { loadSystemPromptFiles } from "./node/system-project-prompts.js";
+import { createPathTrustPolicy } from "./node/trust.js";
 import { runRpcServer } from "./rpc.js";
 export const usage = `Usage: prism [--mode print|json|rpc] [-p prompt] [options]
 
@@ -15,9 +25,19 @@ Options:
   --context <text>           Context text
   --compact <entries>        Auto-compaction threshold
   --max-tool-rounds <n>      Maximum tool rounds
+  --discover                 Enable workspace contribution discovery (opt-in)
+  --discover-kinds <csv>     Kinds to discover (default: skill; skill,tool,context,instructions)
+  --no-discovery             Disable discovery even if --discover is set
+  --agents-config <path>     App config root holding agents/<name>/AGENT.md bundles (opt-in)
+  --no-agents-md             Skip auto-loading <workspaceRoot>/AGENTS.md
+  --no-system-md             Skip auto-loading the global SYSTEM.md layer
+  --agents-md-file <path>    Read AGENTS.md from <path> instead (trust-gated, source: app)
+  --system-md-file <path>    Read SYSTEM.md from <path> instead (source: user)
   -h, --help                 Show this help
 `;
-const valueFlags = new Set(["--prompt", "--mode", "--provider", "--model", "--session", "--config", "--resource", "--extension", "--tool", "--system", "--context", "--compact", "--max-tool-rounds"]);
+const valueFlags = new Set(["--prompt", "--mode", "--provider", "--model", "--session", "--config", "--resource", "--extension", "--tool", "--system", "--context", "--compact", "--max-tool-rounds", "--discover-kinds", "--instruction", "--injector-file", "--agents-md-file", "--system-md-file", "--agents-config"]);
+const boolFlags = new Set(["--discover", "--no-discovery", "--no-agents-md", "--no-system-md"]);
+const ALL_KINDS = ["skill", "tool", "context", "instructions"];
 export function parseCliArgs(argv) {
     let mode = "print";
     let prompt;
@@ -28,11 +48,21 @@ export function parseCliArgs(argv) {
     let compact;
     let maxToolRounds;
     let help = false;
+    let discover = false;
+    let discoverKinds = ["skill"];
+    let noDiscovery = false;
+    let noAgentsMd = false;
+    let noSystemMd = false;
+    let agentsMdFile;
+    let systemMdFile;
+    let agentsConfig;
     const config = [];
     const resources = [];
     const extensions = [];
     const tools = [];
     const context = [];
+    const instructions = [];
+    const injectorFiles = [];
     for (let i = 0; i < argv.length; i += 1) {
         const flag = argv[i];
         if (flag === "-h" || flag === "--help") {
@@ -40,6 +70,23 @@ export function parseCliArgs(argv) {
             continue;
         }
         const name = flag === "-p" ? "--prompt" : flag;
+        if (boolFlags.has(name)) {
+            switch (name) {
+                case "--discover":
+                    discover = true;
+                    break;
+                case "--no-discovery":
+                    noDiscovery = true;
+                    break;
+                case "--no-agents-md":
+                    noAgentsMd = true;
+                    break;
+                case "--no-system-md":
+                    noSystemMd = true;
+                    break;
+            }
+            continue;
+        }
         if (!valueFlags.has(name))
             throw new CliUsageError(`Unknown flag: ${flag}`);
         const value = argv[i + 1];
@@ -88,9 +135,36 @@ export function parseCliArgs(argv) {
             case "--max-tool-rounds":
                 maxToolRounds = positiveInt(value, flag);
                 break;
+            case "--discover-kinds":
+                discoverKinds = parseKinds(value, flag);
+                break;
+            case "--instruction":
+                instructions.push(value);
+                break;
+            case "--injector-file":
+                injectorFiles.push(value);
+                break;
+            case "--agents-md-file":
+                agentsMdFile = value;
+                break;
+            case "--system-md-file":
+                systemMdFile = value;
+                break;
+            case "--agents-config":
+                agentsConfig = value;
+                break;
         }
     }
-    return { mode, prompt, provider, model, session, config, resources, extensions, tools, system, context, compact, maxToolRounds, help };
+    return { mode, prompt, provider, model, session, config, resources, extensions, tools, system, context, compact, maxToolRounds, help, discover, discoverKinds, noDiscovery, agentsConfig, discoveredSkills: [], discoveredInjectors: [], discoveredAgents: [], instructions, injectorFiles, resolvedInstructionInjectors: [], noAgentsMd, noSystemMd, agentsMdFile, systemMdFile, systemPromptLayers: [] };
+}
+function parseKinds(csv, flag) {
+    const kinds = csv.split(",").map((k) => k.trim()).filter(Boolean);
+    if (kinds.length === 0)
+        throw new CliUsageError(`Invalid value for ${flag}: ${csv}`);
+    const invalid = kinds.filter((k) => !ALL_KINDS.includes(k));
+    if (invalid.length > 0)
+        throw new CliUsageError(`Invalid kinds for ${flag}: ${invalid.join(", ")}`);
+    return kinds;
 }
 export async function runCli(argv, runtime) {
     let options;
@@ -112,8 +186,62 @@ export async function runCli(argv, runtime) {
         }
         if (!options.prompt)
             throw new CliUsageError("Missing prompt: use -p or --prompt");
+        const mode = options.mode;
+        // ponytail: discovery is opt-in. --no-discovery hard-disables; default runs never touch the FS.
+        // Registering all kinds honors the plan (tool/context/agent descriptors registered),
+        // but only skills are wired into the mock agent here — other kinds are host-owned execution.
+        let discoveredSkills = options.discoveredSkills;
+        let discoveredInjectors = options.discoveredInjectors;
+        let discoveredAgents = options.discoveredAgents;
+        const workspaceRoot = runtime.workspaceRoot ?? process.cwd();
+        // ponytail: trust policy shared by the repo AGENTS.md loader and the app-config bundle scanner.
+        // --agents-config is an explicit opt-in → its configRoot is a trusted root by that act.
+        const trustedRoots = [workspaceRoot];
+        if (options.agentsConfig)
+            trustedRoots.push(options.agentsConfig);
+        if (options.agentsMdFile)
+            trustedRoots.push(dirname(options.agentsMdFile));
+        const trust = createPathTrustPolicy({ trustedRoots });
+        if (options.discover && !options.noDiscovery) {
+            const discovered = await discoverContributions({
+                kinds: options.discoverKinds,
+                workspaceRoot,
+            });
+            const registries = createContributionRegistries();
+            registerDiscoveredContributions(registries, discovered);
+            discoveredSkills = registries.skills.list();
+            // ponytail: Phase 30 — discovered instruction injectors register host-owned (no core auto-import).
+            await registerDiscoveredInstructionInjectors(registries, discovered);
+            discoveredInjectors = registries.instructionInjectors.list();
+            options = { ...options, discoveredSkills, discoveredInjectors };
+        }
+        // ponytail: Phase 34 — --agents-config discovers app-config agent bundles (envelopes only,
+        // no import()/resolve). Host owns turning a bundle into a live agent via resolveAgentBundle.
+        if (options.agentsConfig) {
+            discoveredAgents = await discoverAgentBundles({ configRoot: options.agentsConfig, trust });
+            options = { ...options, discoveredAgents };
+        }
+        // ponytail: Phase 30 — resolve --instruction names against discovered injectors (fail-closed)
+        // and load --injector-file markdown as static injectors. `--instruction false` disables all.
+        const resolvedInstructionInjectors = options.instructions.includes("false")
+            ? []
+            : await resolveCliInjectors(options.instructions, options.injectorFiles, discoveredInjectors);
+        options = { ...options, resolvedInstructionInjectors };
+        // ponytail: Phase 31/34 — auto-load AGENTS.md (trust-gated, source: app) and the global
+        // SYSTEM.md layer (source: user) as systemPrompt layers composed on top of `--system`.
+        // The CLI no longer defaults globalRoot to the user's home directory; hosts pass globalRoot
+        // explicitly or use --agents-config / --system-md-file. RPC mode skips auto-load (host-owned).
+        if (options.mode !== "rpc") {
+            // ponytail: explicit --agents-md-file opt-in → trust its parent dir too so the named file passes
+            // the containment check (the user named it, so it's trusted by that act).
+            const layers = await loadSystemPromptFiles({
+                ...(options.noAgentsMd ? {} : { workspaceRoot, trust, ...(options.agentsMdFile ? { agentsMdPath: options.agentsMdFile } : {}) }),
+                ...(options.noSystemMd ? {} : { ...(runtime.globalRoot !== undefined ? { globalRoot: runtime.globalRoot } : {}), ...(options.systemMdFile ? { systemMdPath: options.systemMdFile } : {}) }),
+            });
+            options = { ...options, systemPromptLayers: layers };
+        }
         const session = (runtime.createSession ?? defaultCreateSession)(options);
-        await runPromptMode(session, options, runtime.stdout, options.mode);
+        await runPromptMode(session, options, runtime.stdout, mode);
         return 0;
     }
     catch (error) {
@@ -147,14 +275,48 @@ 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 });
+    return createAgent({
+        model,
+        provider: createMockProvider([providerTextDelta("Hello"), providerDone()]),
+        instructions: options.system,
+        // ponytail: Phase 31 — file layers compose with `instructions` (base) via the existing
+        // composeSystemPrompt pipeline; rank order (user<package<app<run) is enforced inside.
+        ...(options.systemPromptLayers.length > 0 ? { systemPrompt: options.systemPromptLayers } : {}),
+        // ponytail: discovered skills become selectable via RunOptions.activeSkills (set by runOptions below).
+        ...(options.discoveredSkills.length > 0 ? { skills: createSkillRegistry(options.discoveredSkills) } : {}),
+    }).createSession({ id: options.session });
 }
 function runOptions(options) {
     return {
         maxToolRounds: options.maxToolRounds,
         compaction: options.compact ? { thresholdEntries: options.compact } : undefined,
+        // ponytail: --discover is the explicit opt-in that activates discovered skills.
+        ...(options.discover && !options.noDiscovery && options.discoveredSkills.length > 0
+            ? { activeSkills: options.discoveredSkills.map((s) => s.name) }
+            : {}),
+        ...(options.resolvedInstructionInjectors.length > 0
+            ? { instructionInjectors: options.resolvedInstructionInjectors }
+            : {}),
     };
 }
+// ponytail: resolve --instruction names against discovered injectors (fail-closed) and load
+// --injector-file markdown files as static every_turn injectors. Names route through
+// resolveInstructionInjectors so an unknown name throws (caught by runCli's error handler).
+async function resolveCliInjectors(names, files, discovered) {
+    const registry = createContributionRegistry({ label: "instruction injector" });
+    for (const inj of discovered)
+        registry.register(inj.name, inj);
+    const byName = names.length ? resolveInstructionInjectors({ registry, names }) : [];
+    const fromFiles = [];
+    for (const path of files) {
+        const text = await readFile(path, "utf8");
+        fromFiles.push({
+            name: basename(path).replace(/\.[^.]+$/, ""),
+            apply: () => ({ instructions: text, when: "every_turn" }),
+        });
+    }
+    return [...byName, ...fromFiles];
+}
 function positiveInt(value, flag) {
     const parsed = Number(value);
     if (!Number.isInteger(parsed) || parsed < 0)

package/dist/compaction.js

@@ -55,6 +55,8 @@ function blockText(block) {
         return block.text;
     if (block.type === "tool_call")
         return `[tool_call ${block.name}]`;
+    if (block.type === "tool_call_delta")
+        return `[tool_call_delta ${block.name ?? block.index}]`;
     if (block.type === "tool_result")
         return `[tool_result ${block.name}]`;
     return "[image]";

package/dist/config.js

@@ -1,9 +1,10 @@
 export function isJsonObject(value) {
-    return isPlainObject(value) && isJsonValue(value);
+    return isPlainObject(value) && isJsonValue(value) && isSafeJsonValue(value);
 }
 export function assertJsonObject(value, label = "value") {
-    if (!isJsonObject(value))
+    if (!isPlainObject(value) || !isJsonValue(value))
         throw new Error(`${label} must be a JSON object`);
+    assertSafeJsonValue(value, label);
 }
 export async function loadConfigLayers(providers, context) {
     const layers = [];
@@ -24,27 +25,32 @@ export function mergeConfigLayers(layers) {
     }
     return merged;
 }
-function mergeObjects(base, override) {
-    const result = { ...cloneJsonObject(base) };
+function mergeObjects(base, override, path = "config") {
+    const result = { ...cloneJsonObject(base, path) };
     for (const [key, value] of Object.entries(override)) {
+        const childPath = `${path}.${key}`;
+        assertSafeJsonKey(key, childPath);
         const current = result[key];
         result[key] = isPlainObject(current) && isPlainObject(value)
-            ? mergeObjects(current, value)
-            : cloneJsonValue(value);
+            ? mergeObjects(current, value, childPath)
+            : cloneJsonValue(value, childPath);
     }
     return result;
 }
-function cloneJsonObject(value) {
+function cloneJsonObject(value, path = "value") {
     const result = {};
-    for (const [key, entry] of Object.entries(value))
-        result[key] = cloneJsonValue(entry);
+    for (const [key, entry] of Object.entries(value)) {
+        const childPath = `${path}.${key}`;
+        assertSafeJsonKey(key, childPath);
+        result[key] = cloneJsonValue(entry, childPath);
+    }
     return result;
 }
-function cloneJsonValue(value) {
+function cloneJsonValue(value, path = "value") {
     if (Array.isArray(value))
-        return value.map(cloneJsonValue);
+        return value.map((entry, index) => cloneJsonValue(entry, `${path}[${index}]`));
     if (isPlainObject(value))
-        return cloneJsonObject(value);
+        return cloneJsonObject(value, path);
     return value;
 }
 function isJsonValue(value) {
@@ -60,6 +66,35 @@ function isJsonValue(value) {
         return Object.values(value).every(isJsonValue);
     return false;
 }
+function isSafeJsonValue(value) {
+    try {
+        assertSafeJsonValue(value, "value");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function assertSafeJsonValue(value, path) {
+    if (Array.isArray(value)) {
+        value.forEach((entry, index) => assertSafeJsonValue(entry, `${path}[${index}]`));
+        return;
+    }
+    if (!isPlainObject(value))
+        return;
+    for (const [key, entry] of Object.entries(value)) {
+        const childPath = `${path}.${key}`;
+        assertSafeJsonKey(key, childPath);
+        assertSafeJsonValue(entry, childPath);
+    }
+}
+function assertSafeJsonKey(key, path) {
+    if (!isSafeJsonKey(key))
+        throw new Error(`${path} uses forbidden JSON key: ${key}`);
+}
+function isSafeJsonKey(key) {
+    return key !== "__proto__" && key !== "prototype" && key !== "constructor";
+}
 function isPlainObject(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value))
         return false;