@yagni-app/code 1.0.0 → 1.0.1

package/dist/feedback.js

@@ -0,0 +1,500 @@
+/**
+ * `yagni feedback [sessionId]` — file a bug report from the shell (YAG-592).
+ *
+ * A shortcut to trigger what `/feedback` does inside a session, but from
+ * outside the TUI. Two modes:
+ *
+ *   Case A (no session arg): list the 10 most recent sessions for the current
+ *     cwd, let the user pick, prompt for a description, confirm, submit.
+ *   Case B (session ID provided): skip the list, go straight to description
+ *     prompt → confirm → submit.
+ *
+ * Self-contained: no cross-package imports. The scrub (`scrubSecrets`) and the
+ * error-trail reader (`readSessionTrail`) are local copies of the extension's
+ * logic — keep in sync with `pi-extension-yagni/src/pipeline/scrubSecrets.ts`
+ * and `pi-extension-yagni/src/errorSink.ts`. The backend re-scrubs server-side
+ * (`backend/src/yagniCode/feedback.ts`), so the client-side scrub is the first
+ * line of defense, not the only one.
+ */
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { isatty } from "node:tty";
+import { agentDir, credentialsDir } from "./credentials.js";
+import { scrubSecrets } from "./crashReport.js";
+import { credentialsFromProfile, readActiveProfile } from "./profiles.js";
+const MAX_DESCRIPTION = 512;
+const MAX_TRANSCRIPT_READ_BYTES = 512 * 1024;
+const MAX_TRAIL_BYTES = 64 * 1024;
+const FIRST_MESSAGE_PREVIEW_FALLBACK = 60;
+/** Max chars for the first-message preview, capped by terminal width. */
+function previewMaxWidth(termCols) {
+    const cols = termCols ?? process.stdout.columns;
+    if (!cols || cols < 40)
+        return FIRST_MESSAGE_PREVIEW_FALLBACK;
+    // Account for: "  " + " N. " (5) + time (18) + dur (6) = ~29 chars of prefix
+    const available = cols - 32;
+    return Math.max(available, 20);
+}
+const LIST_LIMIT = 10;
+// --- session discovery ---
+/**
+ * Encode a cwd into pi's session directory name format:
+ * `/Users/foo/bar` → `--Users-foo-bar--`
+ * Mirrors pi's `migrations.js`: `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`
+ */
+export function encodeCwd(cwd) {
+    return `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+}
+/**
+ * Parse the first few lines of a session JSONL to extract metadata.
+ * Returns null on any failure (corrupt/empty file).
+ */
+function parseSessionHeader(filePath) {
+    try {
+        const data = readFileSync(filePath, "utf8");
+        const lines = data.split("\n").filter((l) => l.length > 0);
+        for (const line of lines) {
+            try {
+                const obj = JSON.parse(line);
+                if (obj.type === "session" && typeof obj.id === "string" && typeof obj.timestamp === "string") {
+                    return { id: obj.id, timestamp: obj.timestamp };
+                }
+            }
+            catch {
+                // skip unparseable lines
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Extract the first user message text from a session JSONL (skips
+ * `custom_message` entries — only real `type: "message"` with `role: "user"`).
+ */
+function extractFirstUserMessage(filePath, maxChars) {
+    try {
+        const data = readFileSync(filePath, "utf8");
+        const lines = data.split("\n").filter((l) => l.length > 0);
+        for (const line of lines) {
+            try {
+                const obj = JSON.parse(line);
+                if (obj.type === "message" &&
+                    obj.message?.role === "user" &&
+                    Array.isArray(obj.message?.content)) {
+                    const textPart = obj.message.content.find((c) => c.type === "text");
+                    if (textPart?.text) {
+                        // Strip skill invocation XML tags (e.g. `<skill name="…" …>`)
+                        // — they're machinery, not the user's message.
+                        let text = textPart.text.trim()
+                            .replace(/<skill\s[^>]*>\s*/g, "")
+                            .replace(/<\/skill>/g, "")
+                            .replace(/\n+/g, " ")
+                            .trim();
+                        const cap = maxChars ?? FIRST_MESSAGE_PREVIEW_FALLBACK;
+                        if (text.length > 0) {
+                            return text.length > cap
+                                ? `${text.slice(0, cap)}…`
+                                : text;
+                        }
+                    }
+                }
+            }
+            catch {
+                // skip unparseable lines
+            }
+        }
+        return "";
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Get the timestamp of the last non-empty line in a session JSONL.
+ * Used to compute session duration.
+ */
+function extractLastTimestamp(filePath) {
+    try {
+        const data = readFileSync(filePath, "utf8");
+        const lines = data.split("\n").filter((l) => l.length > 0);
+        for (let i = lines.length - 1; i >= 0; i--) {
+            try {
+                const obj = JSON.parse(lines[i]);
+                if (typeof obj.timestamp === "string")
+                    return obj.timestamp;
+            }
+            catch {
+                // skip
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * List the most recent sessions for the current cwd.
+ * Scans `<agentDir>/sessions/<encoded-cwd>/*.jsonl`, sorted by start time desc.
+ */
+export function listRecentSessions(agentDirPath, cwd, limit = LIST_LIMIT, termCols) {
+    const sessionsDir = join(agentDirPath, "sessions", encodeCwd(cwd));
+    let files;
+    try {
+        files = readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl"));
+    }
+    catch {
+        return [];
+    }
+    const sessions = [];
+    for (const file of files) {
+        const filePath = join(sessionsDir, file);
+        const header = parseSessionHeader(filePath);
+        if (!header)
+            continue;
+        const firstMessage = extractFirstUserMessage(filePath, previewMaxWidth(termCols));
+        const lastTs = extractLastTimestamp(filePath);
+        let durationMs = null;
+        if (lastTs) {
+            const start = Date.parse(header.timestamp);
+            const end = Date.parse(lastTs);
+            if (!isNaN(start) && !isNaN(end))
+                durationMs = end - start;
+        }
+        sessions.push({
+            id: header.id,
+            filePath,
+            startTime: header.timestamp,
+            durationMs,
+            firstMessage,
+        });
+    }
+    sessions.sort((a, b) => b.startTime.localeCompare(a.startTime));
+    return sessions.slice(0, limit);
+}
+/**
+ * Find a session file by UUID across all project dirs.
+ */
+export function findSessionById(agentDirPath, sessionId) {
+    const sessionsRoot = join(agentDirPath, "sessions");
+    let projectDirs;
+    try {
+        projectDirs = readdirSync(sessionsRoot, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => join(sessionsRoot, d.name));
+    }
+    catch {
+        return null;
+    }
+    for (const dir of projectDirs) {
+        let files;
+        try {
+            files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            if (file.includes(sessionId)) {
+                const filePath = join(dir, file);
+                const header = parseSessionHeader(filePath);
+                if (header)
+                    return { filePath, startTime: header.timestamp };
+            }
+        }
+    }
+    return null;
+}
+// --- transcript + error trail ---
+/**
+ * Read the durable transcript, clamped by byte size. Returns empty on any
+ * failure or when too large. Mirrors the extension's `readTranscript`.
+ */
+export function readTranscript(sessionFile) {
+    if (!sessionFile)
+        return "";
+    try {
+        const data = readFileSync(sessionFile, "utf8");
+        if (Buffer.byteLength(data, "utf8") > MAX_TRANSCRIPT_READ_BYTES)
+            return "";
+        return data;
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Read the session-scoped error trail from today's error sink file.
+ * Filters by sessionId and excludes debug-level entries. Scrubs each line.
+ * Mirrors the extension's `readSessionTrail` — keep in sync.
+ */
+export function readSessionTrail(sessionId, stateDir, maxBytes = MAX_TRAIL_BYTES) {
+    try {
+        const dayStamp = new Date().toISOString().slice(0, 10);
+        const sinkPath = join(stateDir, "logs", `errors-${dayStamp}.jsonl`);
+        const data = readFileSync(sinkPath, "utf8");
+        const lines = data
+            .split("\n")
+            .filter((l) => l.length > 0)
+            .filter((l) => {
+            try {
+                const obj = JSON.parse(l);
+                return obj.sessionId === sessionId && obj.level !== "debug";
+            }
+            catch {
+                return false;
+            }
+        })
+            .map((l) => scrubSecrets(l))
+            .join("\n");
+        return lines.length > maxBytes ? lines.slice(lines.length - maxBytes) : lines;
+    }
+    catch {
+        return "";
+    }
+}
+function buildFeedbackPayload(opts) {
+    const transcript = readTranscript(opts.sessionFile);
+    const trail = readSessionTrail(opts.sessionId, opts.stateDir);
+    return {
+        client: "cli",
+        clientVersion: opts.env.YAGNI_CODE_VERSION?.trim() || opts.clientVersion || "unknown",
+        platform: `${process.platform} ${process.arch}`,
+        description: scrubSecrets(opts.description).slice(0, MAX_DESCRIPTION),
+        sessionId: opts.sessionId,
+        ...(transcript ? { transcriptJsonl: scrubSecrets(transcript) } : {}),
+        ...(trail ? { errorTrailJsonl: trail } : {}),
+    };
+}
+async function submitFeedback(payload, baseUrl, token, fetchImpl) {
+    try {
+        const res = await fetchImpl(`${baseUrl.replace(/\/$/, "")}/api/yagni-code/feedback`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (res.ok) {
+            const body = (await res.json().catch(() => ({})));
+            return { ok: true, id: body.id };
+        }
+        return { ok: false, error: `Server returned ${res.status}` };
+    }
+    catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * Create a readline-like interface that survives piped stdin (where the
+ * real readline's `question` hangs after EOF). For TTY stdin it delegates to
+ * the real `readline/promises`; for piped stdin it reads all lines upfront
+ * and serves them one-by-one.
+ */
+function makeReadline() {
+    if (isatty(0)) {
+        const rl = createInterface({ input, output });
+        return {
+            question: (q) => rl.question(q),
+            close: () => rl.close(),
+        };
+    }
+    // Piped stdin: read all available data and serve lines FIFO.
+    const lines = [];
+    try {
+        const data = readFileSync(0, "utf8"); // fd 0 = stdin
+        for (const line of data.split("\n")) {
+            if (line.length > 0)
+                lines.push(line);
+        }
+    }
+    catch {
+        // stdin not readable as a file — fall back to empty
+    }
+    let idx = 0;
+    return {
+        question: async (q) => {
+            process.stdout.write(q);
+            const answer = lines[idx++] ?? "";
+            // Echo a newline so subsequent prompts start on a new line (in TTY
+            // mode, readline echoes the user's Enter; piped mode does not).
+            process.stdout.write("\n");
+            return answer;
+        },
+        close: () => { },
+    };
+}
+// --- display ---
+function formatDuration(ms) {
+    if (ms === null)
+        return "";
+    if (ms < 1000)
+        return "<1s";
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    return `${m}m`;
+}
+function formatStartTime(iso) {
+    try {
+        const d = new Date(iso);
+        return d.toLocaleString("en-US", {
+            month: "short",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            hour12: false,
+        });
+    }
+    catch {
+        return iso;
+    }
+}
+// Minimal ANSI escape sequences for the session list.
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const CYAN = "\x1b[36m";
+function renderSessionList(sessions) {
+    const sep = DIM + "  " + "─".repeat(70) + RESET;
+    const lines = [BOLD + "  Recent sessions" + RESET, sep];
+    const countWidth = String(sessions.length).length;
+    for (let i = 0; i < sessions.length; i++) {
+        const s = sessions[i];
+        const num = ` ${i + 1}.`.padEnd(countWidth + 2);
+        const idx = GREEN + num + RESET + " ";
+        const time = DIM + formatStartTime(s.startTime).padEnd(17) + RESET + " ";
+        const dur = DIM + formatDuration(s.durationMs).padEnd(5) + RESET + " ";
+        const msg = s.firstMessage || "(no text)";
+        lines.push(`  ${idx}${time}${dur}${msg}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+// --- orchestration ---
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export async function feedbackCommand(args, deps = {}, cliVersion) {
+    const writeOut = deps.writeOut ?? ((line) => void process.stdout.write(`${line}\n`));
+    const writeErr = deps.writeErr ?? ((line) => void process.stderr.write(`${line}\n`));
+    const cwd = deps.cwd ?? process.cwd();
+    const env = deps.env ?? process.env;
+    // Load credentials (same pattern as goCommand).
+    const profile = await (deps.loadCredentials ?? (async () => {
+        const active = await readActiveProfile(env);
+        const creds = credentialsFromProfile(active);
+        return {
+            name: active.name,
+            baseUrl: active.baseUrl,
+            ...(creds?.token ? { token: creds.token } : {}),
+        };
+    }))();
+    if (!profile.token) {
+        writeErr(`Not logged in to environment "${profile.name}" (${profile.baseUrl}). Run \`yagni login\` first.`);
+        return 1;
+    }
+    const agentDirPath = deps.agentDirPath ?? agentDir(profile.name);
+    const stateDir = deps.stateDir ?? credentialsDir();
+    // Parse args: is the first positional a session UUID?
+    const sessionIdArg = args.find((a) => !a.startsWith("-") && UUID_RE.test(a));
+    let sessionFile;
+    let sessionId;
+    // One readline interface for all prompts. For piped stdin, makeReadline
+    // reads all lines upfront to avoid the readline/promises hang on EOF.
+    const rl = deps.readline ?? makeReadline();
+    const closeRl = () => {
+        if (deps.readline)
+            deps.readline.close();
+        else
+            rl.close();
+    };
+    try {
+        if (sessionIdArg) {
+            // Case B: session ID provided directly.
+            const found = findSessionById(agentDirPath, sessionIdArg);
+            if (!found) {
+                writeErr(`Session ${sessionIdArg} not found.`);
+                return 1;
+            }
+            sessionFile = found.filePath;
+            sessionId = sessionIdArg;
+        }
+        else {
+            // Case A: list sessions for the current cwd.
+            const sessions = listRecentSessions(agentDirPath, cwd);
+            if (sessions.length === 0) {
+                writeOut("No recent sessions found for this directory.");
+                return 1;
+            }
+            writeOut(renderSessionList(sessions));
+            const answer = (await rl.question(CYAN + "Select a session (1-" + sessions.length + "): " + RESET)).trim();
+            const idx = parseInt(answer, 10) - 1;
+            if (isNaN(idx) || idx < 0 || idx >= sessions.length) {
+                writeOut("Feedback cancelled.");
+                return 0;
+            }
+            sessionFile = sessions[idx].filePath;
+            sessionId = sessions[idx].id;
+        }
+        // Prompt for description.
+        const descAnswer = await rl.question(DIM + "Describe the issue (one or two lines):" + RESET + "\n> ");
+        const description = descAnswer.trim();
+        if (!description) {
+            writeOut("Feedback cancelled.");
+            return 0;
+        }
+        // Confirm.
+        const transcriptBytes = sessionFile
+            ? Buffer.byteLength(readTranscript(sessionFile), "utf8")
+            : 0;
+        const confirmLines = [
+            DIM + "Sending:" + RESET,
+            `  - Your feedback description`,
+            `  - This session's transcript${transcriptBytes > 0 ? "" : " (could not be read)"}`,
+            `  - Recent error trail for this session`,
+            "",
+            CYAN + "Send this report? [Y/n]" + RESET,
+        ];
+        const confirmed = (await rl.question(confirmLines.join("\n") + "\n")).trim();
+        if (/^n/i.test(confirmed)) {
+            writeOut("Feedback cancelled.");
+            return 0;
+        }
+        // Build payload + submit.
+        const payload = buildFeedbackPayload({
+            sessionId,
+            sessionFile,
+            description,
+            stateDir,
+            env,
+            clientVersion: cliVersion ?? "unknown",
+        });
+        const fetchImpl = deps.fetchImpl ?? fetch;
+        const result = await submitFeedback(payload, profile.baseUrl, profile.token, fetchImpl);
+        if (result.ok) {
+            writeOut(GREEN + "Feedback submitted. Thank you!" + RESET);
+            return 0;
+        }
+        else {
+            writeErr(`Could not submit feedback. ${result.error ?? "Please try again."}`);
+            return 1;
+        }
+    }
+    catch {
+        // readline closed or EOF — treat as cancel.
+        writeOut("Feedback cancelled.");
+        return 0;
+    }
+    finally {
+        closeRl();
+    }
+}
+//# sourceMappingURL=feedback.js.map

package/dist/goHeadless.d.ts

@@ -15,6 +15,7 @@
  * runs locally and what the fleet executes are the same binary and the same
  * pipeline.
  */
+import { type OtelLaunchConfig } from "./otel.js";
 /** Mirrors HEADLESS_GO_EXIT in the extension; duplicated to keep the packages independent. */
 export declare const GO_EXIT: {
     readonly verified: 0;
@@ -64,6 +65,8 @@ export declare function buildHeadlessChildEnv(opts: {
     workspaceId?: string;
     cliVersion?: string;
     sessionId?: string;
+    /** Resolved OTel export config; stage children load pi-otel when present. */
+    otel?: OtelLaunchConfig;
 }): NodeJS.ProcessEnv;
 /**
  * Run `yagni go`. Returns the process exit code: 0 only on a verified

package/dist/goHeadless.js

@@ -20,6 +20,7 @@ import { mkdirSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 import { agentDirEnvVar } from "./branding.js";
 import { agentDir, credentialsDir } from "./credentials.js";
+import { otelChildEnv, resolveOtelLaunchWithWorkspace } from "./otel.js";
 import { credentialsFromProfile, profilePath, readActiveProfile } from "./profiles.js";
 import { resolveHeadlessGoPath, resolvePiCliPath } from "./paths.js";
 /** Mirrors HEADLESS_GO_EXIT in the extension; duplicated to keep the packages independent. */
@@ -54,6 +55,9 @@ export function buildHeadlessChildEnv(opts) {
         PI_CODING_AGENT_DIR: piAgentDir,
         PI_SKIP_VERSION_CHECK: "1",
         PI_TELEMETRY: "0",
+        // OTel export: pin metadata-only capture and forward pi-otel's path so
+        // every stage child spawns with it (see otel.ts for the policy).
+        ...(opts.otel ? otelChildEnv(opts.otel, opts.baseEnv) : {}),
     };
 }
 /**
@@ -88,6 +92,14 @@ export async function goCommand(args, deps = {}, cliVersion) {
         writeErr(`Not logged in to environment "${profile.name}" (${profile.baseUrl}). Run \`yagni login\` first.`);
         return GO_EXIT.usage;
     }
+    // Same OTel gate as an interactive launch — a headless /go run's stage
+    // children are LLM spend too, and the pilot's cost A/B needs to see them.
+    const otel = await resolveOtelLaunchWithWorkspace({
+        env: baseEnv,
+        cwd: deps.cwd ?? process.cwd(),
+        creds: { baseUrl, token },
+        profileName: profile.name,
+    });
     const childEnv = buildHeadlessChildEnv({
         baseEnv,
         token,
@@ -96,6 +108,7 @@ export async function goCommand(args, deps = {}, cliVersion) {
         ...(profile.expiresAt ? { expiresAt: profile.expiresAt } : {}),
         ...(profile.workspaceId ? { workspaceId: profile.workspaceId } : {}),
         ...(cliVersion ? { cliVersion } : {}),
+        ...(otel ? { otel } : {}),
     });
     // The hermetic agent dir must exist before a stage child tries to read it.
     try {

package/dist/launch.d.ts

@@ -6,6 +6,7 @@
  * defaults the provider to `yagni`.
  */
 import type { Credentials } from "./credentials.js";
+import { type OtelLaunchConfig } from "./otel.js";
 export interface LaunchPlan {
     env: NodeJS.ProcessEnv;
     argv: string[];
@@ -92,6 +93,13 @@ export interface BuildLaunchOptions {
      * override the token, base URL, or hermetic agent dir.
      */
     extraEnv?: Record<string, string>;
+    /**
+     * Resolved OTel export config (see `otel.ts`). When present, the session
+     * loads pi-otel alongside our extension and the env pins metadata-only
+     * capture; absent means no OTLP endpoint is configured and the launch is
+     * byte-for-byte what it was before OTel support existed.
+     */
+    otel?: OtelLaunchConfig;
 }
 export declare function buildLaunch(creds: Credentials | null, passthroughArgs: string[], opts: BuildLaunchOptions): LaunchPlan;
 //# sourceMappingURL=launch.d.ts.map

package/dist/launch.js

@@ -7,6 +7,7 @@
  */
 import { randomUUID } from "node:crypto";
 import { agentDirEnvVar } from "./branding.js";
+import { otelChildEnv } from "./otel.js";
 import { PAD_X_ENV, resolvePadX } from "./padding.js";
 import { ENGINEERING_PRACTICE_SECTION, promptEnrichmentDisabled } from "./promptEnrichment.js";
 /**
@@ -105,6 +106,10 @@ export function buildLaunch(creds, passthroughArgs, opts) {
         // the editor (which the launcher pads by seeding editorPaddingX). The
         // footer can't read pi's settings, so the value crosses over env.
         [PAD_X_ENV]: String(resolvePadX()),
+        // OTel export (gated in otel.ts): pin metadata-only capture and forward
+        // pi-otel's path so /go stage children and subagents load it too. Placed
+        // after baseEnv on purpose — the capture pin must beat a user env override.
+        ...(opts.otel ? otelChildEnv(opts.otel, opts.baseEnv ?? {}) : {}),
     };
     // Always load our extension. Default the provider to `yagni` unless the user
     // explicitly chose one (so power users can still point pi elsewhere).
@@ -125,6 +130,7 @@ export function buildLaunch(creds, passthroughArgs, opts) {
     const argv = [
         "-e",
         opts.extensionPath,
+        ...(opts.otel ? ["-e", opts.otel.extensionPath] : []),
         ...(userChoseProvider ? [] : ["--provider", "yagni"]),
         ...(userChoseModel ? [] : ["--model", "advanced"]),
         ...(enrichmentOff ? [] : ["--append-system-prompt", ENGINEERING_PRACTICE_SECTION]),