@yagni-app/code-staging 1.0.0-staging.1175.1 → 1.0.0-staging.1177.1

package/dist/cli.js

@@ -27,6 +27,7 @@ import { login } from "./login.js";
 import { logout } from "./logout.js";
 import { tokenCommand } from "./token.js";
 import { buildLaunch } from "./launch.js";
+import { parseOutputFormat, parseJsonEvents, buildResultObject, readGuardianEvents, } from "./outputFormat.js";
 import { runDoctor } from "./doctor.js";
 import { installProcessCrashHandlers } from "./crashReport.js";
 import { currentCliVersion, maybeNudgeAndRefresh, upgradeCommand } from "./upgrade.js";
@@ -159,6 +160,10 @@ export function seedHideThinkingBlock(piAgentDir) {
     return seedSetting(piAgentDir, "hideThinkingBlock", true);
 }
 async function runDefault(passthroughArgs) {
+    // Parse --output-format out of argv before passing to pi (pi doesn't know
+    // about it). The format determines how we handle pi's stdout: text = inherit,
+    // stream-json = inherit with --mode json, json = pipe + post-process.
+    const { format: outputFormat, remainingArgs } = parseOutputFormat(passthroughArgs);
     // Cache-backed update nudge (never a network wait), then a background cache
     // refresh that completes while the session runs. Both fail soft.
     await maybeNudgeAndRefresh({ current: cliVersion() });
@@ -237,7 +242,7 @@ async function runDefault(passthroughArgs) {
     // re-login in another terminal is picked up here with no stale cached token.
     let plan;
     try {
-        plan = buildLaunch(creds, passthroughArgs, {
+        plan = buildLaunch(creds, remainingArgs, {
             extensionPath: resolveExtensionPath(),
             agentDir: piAgentDir,
             piPackageDir: shadowPiDir,
@@ -260,18 +265,57 @@ async function runDefault(passthroughArgs) {
         process.stderr.write(`${warning}\n`);
     }
     const { env, argv } = plan;
+    // For json/stream-json output, inject --mode json so pi emits NDJSON events.
+    // Don't override if the user already chose --mode (mirrors userChoseProvider/
+    // userChoseModel in buildLaunch). Appended at the end — pi's flag parser
+    // handles --mode anywhere in argv.
+    const userChoseMode = remainingArgs.some((a) => a === "--mode" || a.startsWith("--mode="));
+    const childArgv = outputFormat === "text" || userChoseMode
+        ? argv
+        : [...argv, "--mode", "json"];
+    // text + stream-json: inherit stdout (passthrough). json: pipe stdout so we
+    // can post-process the NDJSON into a single result object.
+    const stdio = outputFormat === "json"
+        ? ["inherit", "pipe", "inherit"]
+        : "inherit";
     const piCli = resolvePiCliPath();
+    const startMs = Date.now();
     return await new Promise((resolve) => {
-        const child = spawn(process.execPath, [piCli, ...argv], {
-            stdio: "inherit",
+        const child = spawn(process.execPath, [piCli, ...childArgv], {
+            stdio: stdio,
             env,
         });
+        // Collect pi's stdout when piping for --output-format json.
+        let stdoutChunks = "";
+        if (outputFormat === "json" && child.stdout) {
+            child.stdout.setEncoding("utf8");
+            child.stdout.on("data", (chunk) => {
+                stdoutChunks += chunk;
+            });
+        }
         // Forward termination signals to pi instead of dying around it (see
         // signalForward.ts for the policy: first signal graceful, second tree-kill).
         installSignalForwarding(child);
         // 128+n for a signal death (bash parity), so a cancelled/killed run never
         // reads as success to scripts or CI.
-        child.on("exit", (code, signal) => resolve(exitCodeFor(code, signal)));
+        child.on("exit", (code, signal) => {
+            const exitCode = exitCodeFor(code, signal);
+            if (outputFormat === "json") {
+                const durationMs = Date.now() - startMs;
+                const events = parseJsonEvents(stdoutChunks);
+                const yagniSessionId = env.YAGNI_SESSION_ID ?? "";
+                const guardianEvents = readGuardianEvents(yagniSessionId);
+                const verbose = remainingArgs.includes("--verbose");
+                const result = buildResultObject({
+                    events,
+                    guardianEvents,
+                    durationMs,
+                    verbose,
+                });
+                process.stdout.write(`${JSON.stringify(result)}\n`);
+            }
+            resolve(exitCode);
+        });
         child.on("error", (err) => {
             process.stderr.write(`Failed to start YAGNI Code: ${err.message}\n`);
             resolve(1);
@@ -286,6 +330,8 @@ export const HELP_TEXT = [
     "  yagni -c                 Continue the most recent session.",
     "  yagni -r                 Browse and resume a previous session.",
     '  yagni -p "prompt"        Print one response and exit (reads piped stdin too).',
+    '  yagni -p "prompt"        Use --output-format json for a machine-readable',
+    '    --output-format json   result object with tools, cost, guardian reviews.',
     "  yagni login              Authorize the active environment (device-code flow).",
     "  yagni logout             Revoke and clear the active environment's token.",
     "  yagni doctor             Check that everything is ready (green/red checklist).",
@@ -307,6 +353,9 @@ export const HELP_TEXT = [
     "  --model <tier>           Model tier (fixed to advanced).",
     "  --thinking <level>       off | minimal | low | medium | high | xhigh | max",
     "  --session <id>           Open a specific session; --fork <id> branches one.",
+    "  --output-format <fmt>    Output format: text (default), json, stream-json.",
+    "                           json emits a single result object; stream-json",
+    "                           emits NDJSON events (same as --mode json).",
     "  --mode json              Emit machine-readable events (for scripts and CI).",
     "",
     "In a session:",

package/dist/outputFormat.d.ts

@@ -0,0 +1,83 @@
+/**
+ * `--output-format` support for headless/print mode (YAG-593).
+ *
+ * The launcher parses `--output-format` out of argv (pi doesn't know about it),
+ * maps it to pi's `--mode json` internally, and post-processes pi's NDJSON
+ * event stream into a single JSON result object — mirroring Claude Code's
+ * `--output-format json` shape.
+ */
+export type OutputFormat = "text" | "json" | "stream-json";
+/**
+ * Strip `--output-format <value>` (or `--output-format=<value>`) from argv.
+ * Returns the format and the remaining args (with the flag removed).
+ * Unknown values fall back to "text" with a stderr warning.
+ */
+export declare function parseOutputFormat(argv: string[], writeErr?: (line: string) => void): {
+    format: OutputFormat;
+    remainingArgs: string[];
+};
+export interface ToolUsed {
+    name: string;
+    is_error: boolean;
+}
+export interface GuardianReview {
+    outcome: string;
+    duration_ms?: number;
+    tier?: string;
+    /** True when the command was blocked (ask in headless or deny). */
+    blocked?: boolean;
+}
+export interface ResultObject {
+    type: "result";
+    subtype: "success" | "error_during_execution";
+    result: string;
+    is_error: boolean;
+    duration_ms: number;
+    num_turns: number;
+    session_id: string;
+    total_cost_usd: number;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_read_tokens: number;
+        total_tokens: number;
+    };
+    tools_used: ToolUsed[];
+    guardian_reviews: GuardianReview[];
+    stop_reason: string | null;
+}
+interface ParsedEvent {
+    type: string;
+    [key: string]: unknown;
+}
+/**
+ * Parse raw NDJSON text (pi's --mode json stdout) into an array of event objects.
+ * Skips blank lines. Fail-soft: unparseable lines are skipped.
+ */
+export declare function parseJsonEvents(raw: string): ParsedEvent[];
+/**
+ * Build the single JSON result object from collected pi events and Guardian
+ * events. Pure — no I/O.
+ *
+ * @param events     NDJSON event objects from pi's --mode json stdout
+ * @param guardian   Guardian review entries from the error sink
+ * @param durationMs Wall-clock time measured by the launcher
+ * @param verbose    When true, returns the raw events array instead of a single object
+ */
+export declare function buildResultObject(opts: {
+    events: ParsedEvent[];
+    guardianEvents?: GuardianReview[];
+    durationMs: number;
+    verbose?: boolean;
+}): ResultObject | ParsedEvent[];
+/**
+ * Read Guardian review events from the error sink JSONL, filtered by
+ * YAGNI_SESSION_ID. The error sink is written by the extension during the
+ * session; this reads it post-run. Fail-soft: returns [] on any error.
+ */
+export declare function readGuardianEvents(yagniSessionId: string, opts?: {
+    homeDir?: string;
+    now?: Date;
+}): GuardianReview[];
+export {};
+//# sourceMappingURL=outputFormat.d.ts.map

package/dist/outputFormat.js

@@ -0,0 +1,207 @@
+/**
+ * `--output-format` support for headless/print mode (YAG-593).
+ *
+ * The launcher parses `--output-format` out of argv (pi doesn't know about it),
+ * maps it to pi's `--mode json` internally, and post-processes pi's NDJSON
+ * event stream into a single JSON result object — mirroring Claude Code's
+ * `--output-format json` shape.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { DISTRIBUTION } from "./distribution.js";
+/**
+ * Strip `--output-format <value>` (or `--output-format=<value>`) from argv.
+ * Returns the format and the remaining args (with the flag removed).
+ * Unknown values fall back to "text" with a stderr warning.
+ */
+export function parseOutputFormat(argv, writeErr = (l) => void process.stderr.write(`${l}\n`)) {
+    const remaining = [];
+    let format = "text";
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--output-format" && i + 1 < argv.length) {
+            const value = argv[++i];
+            if (value === "text" || value === "json" || value === "stream-json") {
+                format = value;
+            }
+            else {
+                writeErr(`Unknown --output-format value "${value}", falling back to text.`);
+            }
+            continue;
+        }
+        if (arg.startsWith("--output-format=")) {
+            const value = arg.slice("--output-format=".length);
+            if (value === "text" || value === "json" || value === "stream-json") {
+                format = value;
+            }
+            else {
+                writeErr(`Unknown --output-format value "${value}", falling back to text.`);
+            }
+            continue;
+        }
+        remaining.push(arg);
+    }
+    return { format, remainingArgs: remaining };
+}
+/**
+ * Parse raw NDJSON text (pi's --mode json stdout) into an array of event objects.
+ * Skips blank lines. Fail-soft: unparseable lines are skipped.
+ */
+export function parseJsonEvents(raw) {
+    const events = [];
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            events.push(JSON.parse(trimmed));
+        }
+        catch {
+            // skip unparseable lines
+        }
+    }
+    return events;
+}
+/**
+ * Build the single JSON result object from collected pi events and Guardian
+ * events. Pure — no I/O.
+ *
+ * @param events     NDJSON event objects from pi's --mode json stdout
+ * @param guardian   Guardian review entries from the error sink
+ * @param durationMs Wall-clock time measured by the launcher
+ * @param verbose    When true, returns the raw events array instead of a single object
+ */
+export function buildResultObject(opts) {
+    const { events, durationMs } = opts;
+    const guardianReviews = opts.guardianEvents ?? [];
+    if (opts.verbose) {
+        return events;
+    }
+    // Session ID from the "session" header event
+    const sessionEvent = events.find((e) => e.type === "session");
+    const sessionId = typeof sessionEvent?.id === "string" ? sessionEvent.id : "";
+    // Count turns
+    const numTurns = events.filter((e) => e.type === "turn_start").length;
+    // Find the final assistant message from agent_end
+    const agentEnd = events.find((e) => e.type === "agent_end");
+    const messages = agentEnd?.messages ?? [];
+    const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
+    let resultText = "";
+    let stopReason = null;
+    if (lastAssistant) {
+        const textContent = lastAssistant.content?.find((c) => c.type === "text");
+        if (textContent?.text) {
+            resultText = textContent.text;
+        }
+        // stopReason is on the assistant message — check message_end events as fallback
+    }
+    // Get stopReason from the last assistant message_end event
+    const assistantMessageEnds = events.filter((e) => e.type === "message_end" && typeof e.message === "object");
+    const lastAssistantEnd = [...assistantMessageEnds]
+        .reverse()
+        .find((e) => e.message?.role === "assistant");
+    if (lastAssistantEnd?.message?.stopReason) {
+        stopReason = lastAssistantEnd.message.stopReason;
+    }
+    // Also try to get result text from message_end if agent_end was missing
+    if (!resultText && lastAssistantEnd?.message?.content) {
+        const textContent = lastAssistantEnd.message.content.find((c) => c.type === "text");
+        if (textContent?.text) {
+            resultText = textContent.text;
+        }
+    }
+    // Aggregate usage and cost across all assistant message_end events
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadTokens = 0;
+    let totalTokens = 0;
+    let totalCostUsd = 0;
+    for (const e of assistantMessageEnds) {
+        const usage = e.message?.usage;
+        if (usage) {
+            inputTokens += usage.input ?? 0;
+            outputTokens += usage.output ?? 0;
+            cacheReadTokens += usage.cacheRead ?? 0;
+            totalTokens += usage.totalTokens ?? 0;
+            totalCostUsd += usage.cost?.total ?? 0;
+        }
+    }
+    // Extract tools used from tool_execution_end events
+    const toolsUsed = events
+        .filter((e) => e.type === "tool_execution_end")
+        .map((e) => ({
+        name: typeof e.toolName === "string" ? e.toolName : "unknown",
+        is_error: e.isError === true,
+    }));
+    // Determine subtype
+    const isError = stopReason === "error" ||
+        stopReason === "aborted" ||
+        (!agentEnd && events.length === 0);
+    const subtype = isError
+        ? "error_during_execution"
+        : "success";
+    return {
+        type: "result",
+        subtype,
+        result: resultText,
+        is_error: isError,
+        duration_ms: durationMs,
+        num_turns: numTurns,
+        session_id: sessionId,
+        total_cost_usd: Math.round(totalCostUsd * 1e6) / 1e6,
+        usage: {
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            cache_read_tokens: cacheReadTokens,
+            total_tokens: totalTokens,
+        },
+        tools_used: toolsUsed,
+        guardian_reviews: guardianReviews,
+        stop_reason: stopReason,
+    };
+}
+// --- Guardian events from the error sink ---
+/**
+ * Read Guardian review events from the error sink JSONL, filtered by
+ * YAGNI_SESSION_ID. The error sink is written by the extension during the
+ * session; this reads it post-run. Fail-soft: returns [] on any error.
+ */
+export function readGuardianEvents(yagniSessionId, opts = {}) {
+    const now = opts.now ?? new Date();
+    const home = opts.homeDir ?? join(homedir(), DISTRIBUTION.stateDirName);
+    const dayStamp = now.toISOString().slice(0, 10);
+    const logPath = join(home, "logs", `errors-${dayStamp}.jsonl`);
+    try {
+        const data = readFileSync(logPath, "utf8");
+        const reviews = [];
+        for (const line of data.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const obj = JSON.parse(trimmed);
+                if (obj.source === "guardian" && obj.sessionId === yagniSessionId) {
+                    reviews.push({
+                        outcome: obj.outcome ?? "unknown",
+                        ...(obj.durationMs !== undefined ? { duration_ms: obj.durationMs } : {}),
+                        ...(obj.tier !== undefined ? { tier: obj.tier } : {}),
+                        // "ask" and "deny" both block the command in headless
+                        ...(obj.outcome === "ask" || obj.outcome === "deny"
+                            ? { blocked: true }
+                            : {}),
+                    });
+                }
+            }
+            catch {
+                // skip unparseable lines
+            }
+        }
+        return reviews;
+    }
+    catch {
+        // file missing, unreadable, etc.
+        return [];
+    }
+}
+//# sourceMappingURL=outputFormat.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.0.0-staging.1175.1",
+  "version": "1.0.0-staging.1177.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -40,5 +40,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "15a46cded8f9e0d2555d02772ca2b0a658684109"
+  "yagniSourceSha": "92209df02c3660ed50b91a72f3197d47c2003e1d"
 }