@yagni-app/code 1.0.0 → 1.0.2

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/dist/paths.d.ts

@@ -29,6 +29,16 @@ export declare function resolveExtensionPath(): string;
  * it pulls in the pipeline alone, with none of pi's TUI surface.
  */
 export declare function resolveHeadlessGoPath(): string;
+/**
+ * Absolute path to the extension's session-worktree entry
+ * (`pipeline/sessionWorktree.js`), the module `yagni -w` imports.
+ *
+ * Mirrors `resolveHeadlessGoPath`: derived from the extension entry so the
+ * bundled-vs-workspace fallback is resolved once. Only this one module is
+ * loaded (not the whole extension): it pulls in the worktree plumbing alone,
+ * with none of pi's TUI surface.
+ */
+export declare function resolveSessionWorktreePath(): string;
 /**
  * Absolute path to pi's package root — the dir whose package.json names the
  * package. The shadow package dir is built from this (we read its package.json

package/dist/paths.js

@@ -43,6 +43,19 @@ export function resolveHeadlessGoPath() {
     const entry = resolveExtensionPath();
     return join(dirname(entry), "pipeline", "headlessGo.js");
 }
+/**
+ * Absolute path to the extension's session-worktree entry
+ * (`pipeline/sessionWorktree.js`), the module `yagni -w` imports.
+ *
+ * Mirrors `resolveHeadlessGoPath`: derived from the extension entry so the
+ * bundled-vs-workspace fallback is resolved once. Only this one module is
+ * loaded (not the whole extension): it pulls in the worktree plumbing alone,
+ * with none of pi's TUI surface.
+ */
+export function resolveSessionWorktreePath() {
+    const entry = resolveExtensionPath();
+    return join(dirname(entry), "pipeline", "sessionWorktree.js");
+}
 /**
  * Absolute path to pi's package root — the dir whose package.json names the
  * package. The shadow package dir is built from this (we read its package.json

package/dist/worktreeArgs.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Pure parsing + validation for `-w / --worktree [name]` (YAG-594).
+ *
+ * No side effects, no I/O: `parseWorktreeFlag` extracts the flag and its
+ * optional value from argv (leaving everything else for pi unchanged), and
+ * `validateWorktreeSlug` mirrors Claude's allowlist so a hostile name is
+ * rejected before the launcher touches git in any way.
+ */
+export interface WorktreeFlag {
+    /** Distinguishes "-w with no name" from "-w absent" so bare `-w` is honored. */
+    requested: boolean;
+    /** The name value, when supplied (`-w foo` / `--worktree=foo`). */
+    name?: string;
+    /** Everything that isn't the worktree flag/name, passed through to pi. */
+    remainingArgs: string[];
+}
+/**
+ * Extract `-w`/`--worktree [name]` from argv without disturbing the rest. Runs
+ * BEFORE `parseOutputFormat` so the two argv-mutators never double-handle a
+ * flag: this strips only the worktree flag, and the caller feeds `remainingArgs`
+ * to `parseOutputFormat` next.
+ */
+export declare function parseWorktreeFlag(argv: string[]): WorktreeFlag;
+/**
+ * Parse a PR reference: `#N` or a GitHub-style PR URL, mirroring the extension's
+ * `parsePRReference` (the two packages stay independent; this is the launcher's
+ * copy so `-w` can recognize a PR ref before slug-validating the raw name).
+ */
+export declare function parsePRReference(input: string): number | null;
+/**
+ * Validate a worktree slug before any side effect. Mirrors Claude's guard:
+ * length cap, per-segment allowlist, `.`/`..` rejection. Throws synchronously
+ * with a clear message (surfaced by the caller).
+ */
+export declare function validateWorktreeSlug(slug: string): void;
+/**
+ * Validate the `-w` name + argv before any side effect. Returns a user-facing
+ * error message when the launch should be refused, or `undefined` to proceed.
+ * PR refs (`#N` / URL) skip slug validation here — they map to `pr-<N>` in the
+ * extension, whose own validation covers the mapped slug.
+ */
+export declare function validateWorktreeLaunchArgs(name: string | undefined, argv: string[]): string | undefined;
+//# sourceMappingURL=worktreeArgs.d.ts.map

package/dist/worktreeArgs.js

@@ -0,0 +1,96 @@
+/**
+ * Pure parsing + validation for `-w / --worktree [name]` (YAG-594).
+ *
+ * No side effects, no I/O: `parseWorktreeFlag` extracts the flag and its
+ * optional value from argv (leaving everything else for pi unchanged), and
+ * `validateWorktreeSlug` mirrors Claude's allowlist so a hostile name is
+ * rejected before the launcher touches git in any way.
+ */
+/** Maximum slug characters (mirrors Claude's guard). */
+const MAX_SLUG_LENGTH = 64;
+/** Allowlist per `/`-separated segment. */
+const VALID_SLUG_SEGMENT = /^[a-zA-Z0-9._-]+$/;
+/**
+ * Extract `-w`/`--worktree [name]` from argv without disturbing the rest. Runs
+ * BEFORE `parseOutputFormat` so the two argv-mutators never double-handle a
+ * flag: this strips only the worktree flag, and the caller feeds `remainingArgs`
+ * to `parseOutputFormat` next.
+ */
+export function parseWorktreeFlag(argv) {
+    const remainingArgs = [];
+    let requested = false;
+    let name;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "-w" || arg === "--worktree") {
+            requested = true;
+            // Consume the next token as the name only if it isn't another flag.
+            const next = argv[i + 1];
+            if (next !== undefined && !next.startsWith("-")) {
+                name = next;
+                i++;
+            }
+            continue;
+        }
+        if (arg.startsWith("--worktree=")) {
+            requested = true;
+            name = arg.slice("--worktree=".length);
+            continue;
+        }
+        remainingArgs.push(arg);
+    }
+    return { requested, name, remainingArgs };
+}
+/**
+ * Parse a PR reference: `#N` or a GitHub-style PR URL, mirroring the extension's
+ * `parsePRReference` (the two packages stay independent; this is the launcher's
+ * copy so `-w` can recognize a PR ref before slug-validating the raw name).
+ */
+export function parsePRReference(input) {
+    const urlMatch = input.match(/^https?:\/\/[^/]+\/[^/]+\/[^/]+\/pull\/(\d+)\/?(?:[?#].*)?$/i);
+    if (urlMatch?.[1])
+        return parseInt(urlMatch[1], 10);
+    const hashMatch = input.match(/^#(\d+)$/);
+    if (hashMatch?.[1])
+        return parseInt(hashMatch[1], 10);
+    return null;
+}
+/**
+ * Validate a worktree slug before any side effect. Mirrors Claude's guard:
+ * length cap, per-segment allowlist, `.`/`..` rejection. Throws synchronously
+ * with a clear message (surfaced by the caller).
+ */
+export function validateWorktreeSlug(slug) {
+    if (slug.length > MAX_SLUG_LENGTH) {
+        throw new Error(`Invalid worktree name: must be ${MAX_SLUG_LENGTH} characters or fewer (got ${slug.length})`);
+    }
+    for (const segment of slug.split("/")) {
+        if (segment === "." || segment === "..") {
+            throw new Error(`Invalid worktree name "${slug}": must not contain "." or ".." path segments`);
+        }
+        if (!VALID_SLUG_SEGMENT.test(segment)) {
+            throw new Error(`Invalid worktree name "${slug}": each "/"-separated segment must be non-empty and contain only letters, digits, dots, underscores, and dashes`);
+        }
+    }
+}
+/**
+ * Validate the `-w` name + argv before any side effect. Returns a user-facing
+ * error message when the launch should be refused, or `undefined` to proceed.
+ * PR refs (`#N` / URL) skip slug validation here — they map to `pr-<N>` in the
+ * extension, whose own validation covers the mapped slug.
+ */
+export function validateWorktreeLaunchArgs(name, argv) {
+    if (name !== undefined && parsePRReference(name) === null) {
+        try {
+            validateWorktreeSlug(name);
+        }
+        catch (err) {
+            return err instanceof Error ? err.message : String(err);
+        }
+    }
+    if (argv.includes("-c") || argv.includes("--continue")) {
+        return "`-c`/`--continue` is not supported with `-w` yet. Use `-w <name>` then `--session <id>` (or `-r`) to resume.";
+    }
+    return undefined;
+}
+//# sourceMappingURL=worktreeArgs.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "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)",
@@ -36,9 +36,10 @@
   "dependencies": {
     "@earendil-works/pi-coding-agent": "0.84.1",
     "@earendil-works/pi-tui": "0.84.1",
+    "pi-otel": "0.1.0",
     "smol-toml": "^1.8.0",
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "4f4236d12f4f4e3b884bbb8b1d357be15eff9962"
+  "yagniSourceSha": "431d2548899146f7522a21fed3488b204b4e77d0"
 }