@chengchenccc/oh-my-agent 0.1.1-rc.1

package/dist/core/workflow/workflow-tools.d.ts

@@ -0,0 +1,50 @@
+import type { PluginTool } from "../agent-runtime.js";
+import type { WorkflowAgentResult, WorkflowAgentSpec, WorkflowRunResult } from "./workflow-executor.js";
+export { isValidWorkflowName, parseAgentDefinition, type SubagentRegistryEntry, } from "./subagent-registry.js";
+export interface WorkflowScriptResult {
+    readonly ok: boolean;
+    readonly totalTokens: number;
+    readonly value: unknown;
+}
+export interface WorkflowToolDeps {
+    readonly runWorkflow: (input: {
+        workflowId: string;
+        label: string;
+        items: readonly WorkflowAgentSpec[];
+        signal?: AbortSignal;
+    }) => Promise<WorkflowRunResult>;
+    /** Executes an orchestration script in the vm sandbox (Phase 2). */
+    readonly runScript: (input: {
+        script: string;
+        args?: unknown;
+    }) => Promise<WorkflowScriptResult>;
+    /** Persist a script to `<workspace>/.oma/workflow/<name>.js` for reuse. */
+    readonly writeScript: (name: string, content: string) => void;
+    /** Load a saved script by name (B8: `workflow_run({name})` re-runs a
+     *  saved workflow without re-supplying the body). null = not found. */
+    readonly readScript: (name: string) => Promise<string | null>;
+    /** 3.4: dispatch ONE named subagent (workflowId/agentId are minted by the
+     *  wiring closure). `signal` is the calling loop's abort signal. */
+    readonly runSubagent: (spec: WorkflowAgentSpec, signal?: AbortSignal) => Promise<WorkflowAgentResult>;
+    /** 3.4: raw markdown of `<workspace>/.oma/agents/<name>.md`, or null when
+     *  absent. The name is already validated before this is called. */
+    readonly readAgentDefinition: (name: string) => Promise<string | null>;
+    /** 3.4 Phase 3 control plane. */
+    readonly listSubagents: () => Array<{
+        handle: string;
+        label: string;
+        status: string;
+        usage?: WorkflowAgentResult["usage"];
+    }>;
+    readonly getSubagentOutput: (handle: string) => {
+        handle: string;
+        status: string;
+        result?: WorkflowAgentResult;
+    };
+    readonly stopSubagent: (handle: string) => {
+        ok: boolean;
+        error?: string;
+    };
+}
+export declare function createWorkflowTools(deps: WorkflowToolDeps): readonly PluginTool[];
+//# sourceMappingURL=workflow-tools.d.ts.map

package/dist/core/workflow/workflow-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-tools.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/workflow-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,KAAK,qBAAqB,GAC3B,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE;QAC5B,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,SAAS,iBAAiB,EAAE,CAAC;QACpC,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACjC,oEAAoE;IACpE,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACjG,2EAA2E;IAC3E,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9D;2EACuE;IACvE,QAAQ,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC9D;wEACoE;IACpE,QAAQ,CAAC,WAAW,EAAE,CACpB,IAAI,EAAE,iBAAiB,EACvB,MAAM,CAAC,EAAE,WAAW,KACjB,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAClC;uEACmE;IACnE,QAAQ,CAAC,mBAAmB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACvE,iCAAiC;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,KAAK,CAAC;QAClC,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC;KACtC,CAAC,CAAC;IACH,QAAQ,CAAC,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK;QAC9C,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,mBAAmB,CAAC;KAC9B,CAAC;IACF,QAAQ,CAAC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5E;AAkBD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,GAAG,SAAS,UAAU,EAAE,CAkNjF"}

package/dist/core/workflow/workflow-tools.js

@@ -0,0 +1,217 @@
+import { builtinAgentNames, isValidWorkflowName, resolveAgent } from "./subagent-registry.js";
+export { isValidWorkflowName, parseAgentDefinition, } from "./subagent-registry.js";
+/** Boundary narrowing: tool args arrive from the model as unknown-shaped
+ *  JSON - validate each field before it enters the executor. */
+function parseItem(raw) {
+    const item = raw;
+    const schema = item.schema;
+    const schemaRec = schema && typeof schema === "object" && !Array.isArray(schema)
+        ? schema
+        : undefined;
+    return {
+        prompt: String(item.prompt ?? ""),
+        ...(typeof item.label === "string" ? { label: item.label } : {}),
+        ...(schemaRec ? { schema: schemaRec } : {}),
+    };
+}
+export function createWorkflowTools(deps) {
+    const runWorkflow = {
+        name: "run_workflow",
+        description: "Fan out independent subagent tasks in parallel and aggregate their results. " +
+            "Each item gets its own isolated agent session (same model, file tools). " +
+            "Use for audits, migrations, and multi-source research. " +
+            "Items: [{prompt, schema?, label?}]. Returns per-item text and schema-validated " +
+            "output (1 retry on violation).",
+        executionMode: "serial",
+        inputSchema: {
+            type: "object",
+            properties: {
+                label: { type: "string" },
+                items: {
+                    type: "array",
+                    maxItems: 64,
+                    items: {
+                        type: "object",
+                        properties: {
+                            prompt: { type: "string" },
+                            label: { type: "string" },
+                            schema: { type: "object" },
+                        },
+                        required: ["prompt"],
+                    },
+                },
+            },
+            required: ["items"],
+        },
+        async execute(args, signal) {
+            const rawItems = Array.isArray(args.items) ? args.items : [];
+            const workflowId = `wf-${crypto.randomUUID()}`;
+            const result = await deps.runWorkflow({
+                workflowId,
+                label: typeof args.label === "string" ? args.label : "workflow",
+                items: rawItems.map(parseItem),
+                ...(signal ? { signal } : {}),
+            });
+            return { items: result.items, totalTokens: result.totalTokens, ok: result.ok };
+        },
+    };
+    const runScript = {
+        name: "workflow_run",
+        description: "Run an orchestration script (top-level-await JS) that fans out subagents " +
+            "via agent(prompt, {schema?, label?}) and pipeline(items, fn). Scripts have " +
+            "NO fs/network access - agents do the work. Save reusable scripts with the " +
+            "name argument (written to .oma/workflow/<name>.js), then re-run one later " +
+            "with ONLY the name argument (loads the saved script).",
+        executionMode: "serial",
+        inputSchema: {
+            type: "object",
+            properties: {
+                // script XOR name: either a new body, or a saved workflow to re-run
+                // (the runtime enforces the XOR — at least one must be present).
+                script: { type: "string", maxLength: 32768 },
+                name: { type: "string" },
+                args: { type: "object" },
+            },
+        },
+        async execute(args) {
+            const rawScript = typeof args.script === "string" ? args.script : "";
+            const name = typeof args.name === "string" && args.name.length > 0 ? args.name : null;
+            if (name && !isValidWorkflowName(name)) {
+                return { ok: false, error: `invalid workflow name (allowed: [a-z0-9-], max 64): ${name}` };
+            }
+            if (rawScript && name)
+                deps.writeScript(name, rawScript);
+            let script = rawScript;
+            if (!script && name) {
+                const saved = await deps.readScript(name);
+                if (saved === null) {
+                    return { ok: false, error: `workflow "${name}" not found in .oma/workflow` };
+                }
+                script = saved;
+            }
+            if (!script)
+                return { ok: false, error: "script or name is required" };
+            const result = await deps.runScript({ script, args: args.args });
+            return {
+                ok: result.ok,
+                totalTokens: result.totalTokens,
+                value: result.value,
+                scriptSaved: Boolean(rawScript && name),
+            };
+        },
+    };
+    const task = {
+        name: "task",
+        description: "Dispatch ONE named subagent as a task and get its final answer. Roles: " +
+            "explore (read-only investigation), worker (full file tools), or any " +
+            ".oma/agents/<name>.md definition in the workspace. " +
+            "Args: {agent, prompt, schema?, background?}. The result carries a " +
+            "handle; pass {resume: <handle>, prompt} to continue the SAME subagent " +
+            "with a follow-up. background:true returns immediately with the handle " +
+            "(poll it via task_output). For parallel fan-out use run_workflow.",
+        executionMode: "serial",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agent: { type: "string" },
+                prompt: { type: "string" },
+                schema: { type: "object" },
+                resume: { type: "string" },
+                background: { type: "boolean" },
+            },
+            // agent XOR resume (with prompt required either way); runtime enforces.
+        },
+        async execute(args, signal) {
+            const agent = typeof args.agent === "string" ? args.agent.trim() : "";
+            const prompt = typeof args.prompt === "string" ? args.prompt : "";
+            const resume = typeof args.resume === "string" ? args.resume.trim() : "";
+            if (!prompt)
+                return { ok: false, error: "prompt is required" };
+            if (resume) {
+                const result = await deps.runSubagent({ prompt, ...(agent ? { label: agent } : {}), resumeHandle: resume }, signal);
+                return { label: result.label, text: result.text, ok: result.ok };
+            }
+            if (!agent)
+                return { ok: false, error: "agent (or resume handle) and prompt are required" };
+            const def = await resolveAgent(agent, deps.readAgentDefinition);
+            if (!def) {
+                const builtin = builtinAgentNames().join(", ");
+                return {
+                    ok: false,
+                    error: `unknown subagent "${agent}" (builtin: ${builtin}; or .oma/agents/<name>.md)`,
+                };
+            }
+            const schema = args.schema;
+            const result = await deps.runSubagent({
+                prompt,
+                label: agent,
+                ...(schema && typeof schema === "object" && !Array.isArray(schema)
+                    ? { schema: schema }
+                    : {}),
+                systemPrompt: def.systemPrompt,
+                ...(def.tools ? { toolNames: def.tools } : {}),
+                ...(def.modelId ? { modelId: def.modelId } : {}),
+                ...(args.background === true ? { background: true } : {}),
+            }, signal);
+            return {
+                label: result.label,
+                text: result.text,
+                ok: result.ok,
+                ...(result.output !== undefined ? { output: result.output } : {}),
+                ...(result.error ? { error: result.error } : {}),
+                ...(result.usage ? { usage: result.usage } : {}),
+                ...(result.artifacts ? { artifacts: result.artifacts } : {}),
+                ...(result.handle ? { handle: result.handle } : {}),
+                ...(result.status ? { status: result.status } : {}),
+            };
+        },
+    };
+    const taskList = {
+        name: "task_list",
+        description: "List live task handles (label, status, usage).",
+        executionMode: "serial",
+        inputSchema: { type: "object", properties: {} },
+        async execute() {
+            return { tasks: deps.listSubagents() };
+        },
+    };
+    const taskOutput = {
+        name: "task_output",
+        description: "Read a background task by handle: status (running/completed/failed/stopped) " +
+            "and the result once finished.",
+        executionMode: "serial",
+        inputSchema: {
+            type: "object",
+            properties: { handle: { type: "string" } },
+            required: ["handle"],
+        },
+        async execute(args) {
+            const handle = typeof args.handle === "string" ? args.handle.trim() : "";
+            if (!handle)
+                return { ok: false, error: "handle is required" };
+            const out = deps.getSubagentOutput(handle);
+            return {
+                handle: out.handle,
+                status: out.status,
+                ...(out.result ? { result: out.result } : {}),
+            };
+        },
+    };
+    const taskStop = {
+        name: "task_stop",
+        description: "Stop a live background task by handle.",
+        executionMode: "serial",
+        inputSchema: {
+            type: "object",
+            properties: { handle: { type: "string" } },
+            required: ["handle"],
+        },
+        async execute(args) {
+            const handle = typeof args.handle === "string" ? args.handle.trim() : "";
+            if (!handle)
+                return { ok: false, error: "handle is required" };
+            return deps.stopSubagent(handle);
+        },
+    };
+    return [runWorkflow, runScript, task, taskList, taskOutput, taskStop];
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/** Oma product public API: the single Runtime factory plus the
+ *  pieces the modes are built from. Everything else (CLI entry, RPC/JSON/
+ *  print modes) is app-internal. */
+export { type CliArgs, type CliMode, parseArgs, UsageError } from "./cli/args.js";
+export { buildCliRunInput } from "./cli/initial-input.js";
+export { type CreateOmaRuntimeOptions, createOmaRuntime, type OmaRuntime, } from "./core/runtime/create-runtime.js";
+export { buildBackendModelCatalog, type ModelCatalogOptions, } from "./core/runtime/model-catalog.js";
+export { assembleRunRuntime, type RunRuntime, type RunRuntimeDeps, registerBuiltinProviders, } from "./core/runtime/run-runtime.js";
+export { registerProvidersFromCatalog } from "./core/runtime/runtime-catalog.js";
+export { runJsonMode } from "./modes/json-mode.js";
+export { assistantText, type CliRunOptions, runPrintMode } from "./modes/print-mode.js";
+export { createJsonlReader, type JsonlReaderOptions } from "./modes/rpc/jsonl.js";
+export { type RpcModeController, type RpcModeOptions, runRpcMode } from "./modes/rpc/rpc-mode.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;oCAEoC;AAEpC,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAClF,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EACL,KAAK,uBAAuB,EAC5B,gBAAgB,EAChB,KAAK,UAAU,GAChB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EACL,wBAAwB,EACxB,KAAK,mBAAmB,GACzB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,kBAAkB,EAClB,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,wBAAwB,GACzB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAC;AACjF,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACxF,OAAO,EAAE,iBAAiB,EAAE,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,EAAE,KAAK,iBAAiB,EAAE,KAAK,cAAc,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+/** Oma product public API: the single Runtime factory plus the
+ *  pieces the modes are built from. Everything else (CLI entry, RPC/JSON/
+ *  print modes) is app-internal. */
+export { parseArgs, UsageError } from "./cli/args.js";
+export { buildCliRunInput } from "./cli/initial-input.js";
+export { createOmaRuntime, } from "./core/runtime/create-runtime.js";
+export { buildBackendModelCatalog, } from "./core/runtime/model-catalog.js";
+export { assembleRunRuntime, registerBuiltinProviders, } from "./core/runtime/run-runtime.js";
+export { registerProvidersFromCatalog } from "./core/runtime/runtime-catalog.js";
+export { runJsonMode } from "./modes/json-mode.js";
+export { assistantText, runPrintMode } from "./modes/print-mode.js";
+export { createJsonlReader } from "./modes/rpc/jsonl.js";
+export { runRpcMode } from "./modes/rpc/rpc-mode.js";

package/dist/main.d.ts

@@ -0,0 +1,9 @@
+export declare const OMA_VERSION = "0.1.0";
+/** Parse args, run one CLI invocation, and return the process exit code.
+ *  Never calls process.exit() - callers own exit-code assignment so stdout
+ *  protocol output can flush. Pure enough to be imported from tests. */
+export declare function main(argv?: string[]): Promise<number>;
+/** CLI entry wrapper: run main() and map errors to stderr + exit codes.
+ *  Used by src/cli.ts (the executable entry) and tests. */
+export declare function runCli(argv?: string[]): Promise<void>;
+//# sourceMappingURL=main.d.ts.map

package/dist/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,WAAW,UAAU,CAAC;AAEnC;;wEAEwE;AACxE,wBAAsB,IAAI,CAAC,IAAI,GAAE,MAAM,EAA0B,GAAG,OAAO,CAAC,MAAM,CAAC,CAwElF;AAED;2DAC2D;AAC3D,wBAAsB,MAAM,CAAC,IAAI,GAAE,MAAM,EAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAYlF"}

package/dist/main.js

@@ -0,0 +1,97 @@
+import { createModelRuntime } from "@chengchenccc/ai";
+import { parseArgs, UsageError } from "./cli/args.js";
+import { mergeInitialInput, readPipedStdin } from "./cli/initial-input.js";
+import { buildBackendModelCatalog } from "./core/runtime/model-catalog.js";
+import { registerBuiltinProviders } from "./core/runtime/run-runtime.js";
+import { parseToolFilter } from "./core/runtime/tool-filter.js";
+import { runJsonMode } from "./modes/json-mode.js";
+import { runPrintMode } from "./modes/print-mode.js";
+import { runRpcMode } from "./modes/rpc/rpc-mode.js";
+import { runTuiMode } from "./modes/tui/tui-mode.js";
+export const OMA_VERSION = "0.1.0";
+/** Parse args, run one CLI invocation, and return the process exit code.
+ *  Never calls process.exit() - callers own exit-code assignment so stdout
+ *  protocol output can flush. Pure enough to be imported from tests. */
+export async function main(argv = process.argv.slice(2)) {
+    const args = parseArgs(argv);
+    const modelRuntime = createModelRuntime();
+    registerBuiltinProviders(modelRuntime, process.env);
+    if (args.listModels) {
+        // stdout carries ONLY the catalog JSON (the adapter parses it).
+        const catalog = await buildBackendModelCatalog({ modelRuntime });
+        process.stdout.write(`${JSON.stringify(catalog)}\n`);
+        return 0;
+    }
+    if (args.mode === "rpc") {
+        // RPC stdin is the JSONL command stream: NEVER pre-read it.
+        const controller = runRpcMode({ modelRuntime });
+        let signaled = false;
+        const onSignal = () => {
+            if (signaled)
+                return;
+            signaled = true;
+            controller.stop();
+        };
+        process.on("SIGTERM", onSignal);
+        process.on("SIGINT", onSignal);
+        try {
+            return await controller.promise;
+        }
+        finally {
+            process.off("SIGTERM", onSignal);
+            process.off("SIGINT", onSignal);
+        }
+    }
+    if (args.mode === "tui") {
+        return runTuiMode({
+            modelRuntime,
+            workspaceRoot: process.cwd(),
+            model: args.model,
+            sessionId: args.session,
+        });
+    }
+    // Standalone default: `oma` (or `oma "<prompt>"`) on a TTY opens the
+    // TUI, with the positional prompt prefilled into the editor. Explicit
+    // -p/--mode or a pipe stays one-shot print/json.
+    if (!args.modeExplicit && process.stdin.isTTY) {
+        return runTuiMode({
+            modelRuntime,
+            workspaceRoot: process.cwd(),
+            model: args.model,
+            sessionId: args.session,
+            ...(args.tools ? { toolFilter: parseToolFilter(args.tools) } : {}),
+            ...(args.prompt ? { initialPrompt: args.prompt } : {}),
+        });
+    }
+    const prompt = mergeInitialInput({
+        prompt: args.prompt,
+        piped: await readPipedStdin(),
+    });
+    if (!prompt) {
+        throw new UsageError('bare oma opens the interactive TUI - run it in a terminal. Outside a terminal, give a prompt: oma -p "<prompt>" (or piped stdin)');
+    }
+    const opts = {
+        prompt,
+        workspaceRoot: process.cwd(),
+        modelRuntime,
+        model: args.model,
+        ...(args.tools ? { toolFilter: parseToolFilter(args.tools) } : {}),
+    };
+    return args.mode === "json" ? runJsonMode(opts) : runPrintMode(opts);
+}
+/** CLI entry wrapper: run main() and map errors to stderr + exit codes.
+ *  Used by src/cli.ts (the executable entry) and tests. */
+export async function runCli(argv = process.argv.slice(2)) {
+    try {
+        process.exitCode = await main(argv);
+    }
+    catch (err) {
+        if (err instanceof UsageError) {
+            process.stderr.write(`${err.message}\n`);
+            process.exitCode = 2;
+            return;
+        }
+        process.stderr.write(`[oma] failed: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exitCode = 1;
+    }
+}

package/dist/modes/json-mode.d.ts

@@ -0,0 +1,5 @@
+import type { CliRunOptions } from "./print-mode.js";
+/** JSON mode: one Run; stdout gets ALL events as JSONL plus exactly one
+ *  terminal outcome line; then the process exits. stderr for logs only. */
+export declare function runJsonMode(opts: CliRunOptions): Promise<number>;
+//# sourceMappingURL=json-mode.d.ts.map

package/dist/modes/json-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-mode.d.ts","sourceRoot":"","sources":["../../src/modes/json-mode.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD;2EAC2E;AAC3E,wBAAsB,WAAW,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAuCtE"}

package/dist/modes/json-mode.js

@@ -0,0 +1,46 @@
+import { buildCliRunInput } from "../cli/initial-input.js";
+import { assemblePluginRuntime } from "../core/plugins/plugin-resolve.js";
+import { denyAllApprovals } from "../core/runtime/approval.js";
+import { createOmaRuntime } from "../core/runtime/create-runtime.js";
+/** JSON mode: one Run; stdout gets ALL events as JSONL plus exactly one
+ *  terminal outcome line; then the process exits. stderr for logs only. */
+export async function runJsonMode(opts) {
+    const built = await buildCliRunInput({
+        prompt: opts.prompt,
+        workspaceRoot: opts.workspaceRoot,
+        modelRuntime: opts.modelRuntime,
+    });
+    const pluginRt = await assemblePluginRuntime(built.workspace.root, "json");
+    for (const w of pluginRt.warnings)
+        console.error(`[plugin] ${w}`);
+    const runtime = await createOmaRuntime({
+        runId: built.run.runId,
+        modelId: built.run.model.modelId,
+        workspaceRoot: built.workspace.root,
+        workspaceAccess: built.workspace.access,
+        modelRuntime: opts.modelRuntime,
+        skillRoots: built.run.skillRoots ?? [],
+        gateWorkspaceMcp: true,
+        approvalHandler: denyAllApprovals,
+        ...(pluginRt.plugins.length || pluginRt.mcpServers.length
+            ? { pluginComponents: { plugins: pluginRt.plugins, mcpServers: pluginRt.mcpServers } }
+            : {}),
+        ...(built.run.permissionMode ? { permissionMode: built.run.permissionMode } : {}),
+        ...(opts.toolFilter ? { toolFilter: opts.toolFilter } : {}),
+        onEvent: (envelope) => {
+            // Raw runtime event object, e.g. {"type":"agent_start"}.
+            process.stdout.write(`${JSON.stringify({ type: "event", event: envelope.data })}\n`);
+        },
+    });
+    try {
+        const segment = await runtime.run(built);
+        const outcome = await segment.outcome;
+        process.stdout.write(`${JSON.stringify({ type: "outcome", outcome })}\n`);
+        return outcome.status === "completed" ? 0 : 1;
+    }
+    finally {
+        await runtime.close().catch(() => { });
+        // One-shot process: wait for the background memory pass (see print mode).
+        await runtime.memoryLearning()?.catch(() => { });
+    }
+}

package/dist/modes/print-mode.d.ts

@@ -0,0 +1,20 @@
+import type { ModelRuntime } from "@chengchenccc/ai";
+import type { Message } from "@chengchenccc/message";
+import type { ToolFilter } from "../core/runtime/tool-filter.js";
+export interface CliRunOptions {
+    prompt: string;
+    workspaceRoot: string;
+    modelRuntime: ModelRuntime;
+    /** Canonical `<provider>/<model>` id; undefined = first available. */
+    model?: string;
+    /** --tools filter (CLI): applied to the final tool table. */
+    toolFilter?: ToolFilter;
+}
+/** Final assistant text of an outcome Message: the plain `text` field, or the
+ *  concatenated text blocks. Never falls back to placeholder text. */
+export declare function assistantText(message: Message | undefined): string;
+/** Print mode: one Run, one prompt; stdout gets ONLY the final assistant
+ *  text; failures go to stderr with a non-zero exit code. The completed
+ *  turn is persisted to a fresh session file (stdout stays clean). */
+export declare function runPrintMode(opts: CliRunOptions): Promise<number>;
+//# sourceMappingURL=print-mode.d.ts.map

package/dist/modes/print-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print-mode.d.ts","sourceRoot":"","sources":["../../src/modes/print-mode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAKrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAIjE,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,YAAY,CAAC;IAC3B,sEAAsE;IACtE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AACD;sEACsE;AACtE,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAUlE;AAED;;sEAEsE;AACtE,wBAAsB,YAAY,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAsDvE"}

package/dist/modes/print-mode.js

@@ -0,0 +1,82 @@
+import { buildCliRunInput } from "../cli/initial-input.js";
+import { assemblePluginRuntime } from "../core/plugins/plugin-resolve.js";
+import { denyAllApprovals } from "../core/runtime/approval.js";
+import { createOmaRuntime } from "../core/runtime/create-runtime.js";
+import { newSessionId } from "../core/session/session-file.js";
+import { persistSessionTurn } from "../core/session/session-loop.js";
+/** Final assistant text of an outcome Message: the plain `text` field, or the
+ *  concatenated text blocks. Never falls back to placeholder text. */
+export function assistantText(message) {
+    if (!message)
+        return "";
+    if (typeof message.text === "string" && message.text.length > 0)
+        return message.text;
+    if (Array.isArray(message.blocks)) {
+        return message.blocks
+            .filter((b) => b.type === "text" && typeof b.text === "string")
+            .map((b) => b.text)
+            .join("\n");
+    }
+    return "";
+}
+/** Print mode: one Run, one prompt; stdout gets ONLY the final assistant
+ *  text; failures go to stderr with a non-zero exit code. The completed
+ *  turn is persisted to a fresh session file (stdout stays clean). */
+export async function runPrintMode(opts) {
+    const built = await buildCliRunInput({
+        prompt: opts.prompt,
+        workspaceRoot: opts.workspaceRoot,
+        modelRuntime: opts.modelRuntime,
+        modelId: opts.model,
+    });
+    const sessionId = newSessionId();
+    const pluginRt = await assemblePluginRuntime(built.workspace.root, "print");
+    for (const w of pluginRt.warnings)
+        console.error(`[plugin] ${w}`);
+    const runtime = await createOmaRuntime({
+        runId: built.run.runId,
+        modelId: built.run.model.modelId,
+        workspaceRoot: built.workspace.root,
+        workspaceAccess: built.workspace.access,
+        modelRuntime: opts.modelRuntime,
+        skillRoots: built.run.skillRoots ?? [],
+        gateWorkspaceMcp: true,
+        approvalHandler: denyAllApprovals,
+        ...(pluginRt.plugins.length || pluginRt.mcpServers.length
+            ? { pluginComponents: { plugins: pluginRt.plugins, mcpServers: pluginRt.mcpServers } }
+            : {}),
+        ...(built.run.permissionMode ? { permissionMode: built.run.permissionMode } : {}),
+        ...(opts.toolFilter ? { toolFilter: opts.toolFilter } : {}),
+    });
+    try {
+        const segment = await runtime.run(built);
+        const outcome = await segment.outcome;
+        if (outcome.status === "completed") {
+            await persistSessionTurn({
+                sessionId,
+                cwd: opts.workspaceRoot,
+                runtime,
+                // One-shot mode: no real-time hook, write the whole turn at once.
+                messages: [built.input.message, ...(outcome.messages ?? [])],
+            });
+            // Final answer = the last assistant message with text in the
+            // canonical sequence (ADR 0017).
+            const finalAnswer = [...(outcome.messages ?? [])]
+                .reverse()
+                .find((m) => m.role === "assistant" && (m.text?.trim() ?? "") !== "");
+            const text = assistantText(finalAnswer);
+            if (text)
+                process.stdout.write(`${text}\n`);
+            return 0;
+        }
+        process.stderr.write(`[oma] run failed: ${outcome.error ?? outcome.status}\n`);
+        return 1;
+    }
+    finally {
+        await runtime.close().catch(() => { });
+        // The memory-learn pass is fire-and-forget: a one-shot process must not
+        // exit before it settles, or the run's facts are lost (it has its own
+        // 60s bound, so this await cannot hang).
+        await runtime.memoryLearning()?.catch(() => { });
+    }
+}

package/dist/modes/rpc/jsonl.d.ts

@@ -0,0 +1,23 @@
+/** Strict LF-framed JSONL reader (Pi-style).
+ *
+ *  - Only `\n` (0x0A) splits frames - a generic line reader that also splits
+ *    on Unicode separators would corrupt payloads.
+ *  - Byte-buffer based: half packets accumulate until the next LF.
+ *  - A single frame is bounded (`maxLineBytes`); oversized frames are skipped
+ *    and reported via `onOversize`. The buffer is trimmed so a hostile peer
+ *    cannot grow memory without bound - trimmed bytes belong to an oversized
+ *    frame, which is discarded up to its terminating LF. */
+export interface JsonlReaderOptions {
+    /** Max bytes of one frame (default 16 MiB - history projections can be large). */
+    maxLineBytes?: number;
+    onOversize?: (length: number) => void;
+}
+export interface JsonlReader {
+    readonly lines: AsyncIterable<string>;
+    /** End the read loop as if the stream closed: the pending read resolves
+     *  `{done: true}` and the iterator finishes cleanly. Used by RPC mode to
+     *  exit the process on its own after the outcome. */
+    cancel(): Promise<void>;
+}
+export declare function createJsonlReader(stream: ReadableStream<Uint8Array>, opts?: JsonlReaderOptions): JsonlReader;
+//# sourceMappingURL=jsonl.d.ts.map

package/dist/modes/rpc/jsonl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl.d.ts","sourceRoot":"","sources":["../../../src/modes/rpc/jsonl.ts"],"names":[],"mappings":"AAAA;;;;;;;;4DAQ4D;AAE5D,MAAM,WAAW,kBAAkB;IACjC,kFAAkF;IAClF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC;;yDAEqD;IACrD,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,EAClC,IAAI,GAAE,kBAAuB,GAC5B,WAAW,CAqEb"}