newpr 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newpr",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "AI-powered large PR review tool - understand PRs with 1000+ lines of changes",
   "module": "src/cli/index.ts",
   "type": "module",

package/src/stack/publish.ts

@@ -46,9 +46,9 @@ export async function publishStack(input: PublishInput): Promise<StackPublishRes
 			? `[${order}/${total}] ${gc.pr_title}`
 			: `[Stack ${order}/${total}] ${gc.group_id}`;
 
-		const body = buildPrBody(gc.group_id, order, total, exec_result, pr_meta);
+		const placeholder = buildPlaceholderBody(gc.group_id, order, total, pr_meta);
 
-		const prResult = await Bun.$`gh pr create --repo ${ghRepo} --base ${prBase} --head ${gc.branch_name} --title ${title} --body ${body} --draft`.quiet().nothrow();
+		const prResult = await Bun.$`gh pr create --repo ${ghRepo} --base ${prBase} --head ${gc.branch_name} --title ${title} --body ${placeholder} --draft`.quiet().nothrow();
 
 		if (prResult.exitCode === 0) {
 			const prUrl = prResult.stdout.toString().trim();
@@ -68,29 +68,84 @@ export async function publishStack(input: PublishInput): Promise<StackPublishRes
 		}
 	}
 
+	await updatePrBodies(ghRepo, prs, pr_meta);
+
 	return { branches, prs };
 }
 
-function buildPrBody(
+async function updatePrBodies(ghRepo: string, prs: PrInfo[], prMeta: PrMeta): Promise<void> {
+	if (prs.length === 0) return;
+
+	for (let i = 0; i < prs.length; i++) {
+		const pr = prs[i]!;
+		const body = buildFullBody(pr, i, prs, prMeta);
+
+		await Bun.$`gh pr edit ${pr.number} --repo ${ghRepo} --body ${body}`.quiet().nothrow();
+	}
+}
+
+function buildPlaceholderBody(
 	groupId: string,
 	order: number,
 	total: number,
-	_execResult: StackExecResult,
 	prMeta: PrMeta,
 ): string {
-	const prevPr = order > 1 ? `Previous: Stack ${order - 1}/${total}` : "Previous: (base branch)";
-	const nextPr = order < total ? `Next: Stack ${order + 1}/${total}` : "Next: (top of stack)";
-
-	const lines = [
-		`> This is part of a stacked PR chain created by [newpr](${prMeta.pr_url})`,
-		`>`,
-		`> **Stack order**: ${order}/${total}`,
-		`> **${prevPr}** | **${nextPr}**`,
+	return [
+		`> This is part of a stacked PR chain created by [newpr](https://github.com/jiwonMe/newpr).`,
+		`> Stack order: ${order}/${total} — body will be updated with links shortly.`,
 		``,
 		`## ${groupId}`,
 		``,
 		`*From PR #${prMeta.pr_number}: ${prMeta.pr_title}*`,
-	];
+	].join("\n");
+}
+
+function buildFullBody(
+	current: PrInfo,
+	index: number,
+	allPrs: PrInfo[],
+	prMeta: PrMeta,
+): string {
+	const total = allPrs.length;
+	const order = index + 1;
+
+	const stackTable = allPrs.map((pr, i) => {
+		const num = i + 1;
+		const isCurrent = i === index;
+		const marker = isCurrent ? "👉" : statusEmoji(i, index);
+		const link = `[#${pr.number}](${pr.url})`;
+		const titleText = pr.title.replace(/^\[\d+\/\d+\]\s*/, "");
+		return `| ${marker} | ${num}/${total} | ${link} | ${titleText} |`;
+	}).join("\n");
+
+	const prev = index > 0
+		? `⬅️ Previous: [#${allPrs[index - 1]!.number}](${allPrs[index - 1]!.url})`
+		: "⬅️ Previous: base branch";
+	const next = index < total - 1
+		? `➡️ Next: [#${allPrs[index + 1]!.number}](${allPrs[index + 1]!.url})`
+		: "➡️ Next: top of stack";
+
+	return [
+		`> **Stack ${order}/${total}** — This PR is part of a stacked PR chain created by [newpr](https://github.com/jiwonMe/newpr).`,
+		`> Source: #${prMeta.pr_number} ${prMeta.pr_title}`,
+		``,
+		`### 📚 Stack Navigation`,
+		``,
+		`| | Order | PR | Title |`,
+		`|---|---|---|---|`,
+		stackTable,
+		``,
+		`${prev} | ${next}`,
+		``,
+		`---`,
+		``,
+		`## ${current.group_id}`,
+		``,
+		`*From PR [#${prMeta.pr_number}](${prMeta.pr_url}): ${prMeta.pr_title}*`,
+	].join("\n");
+}
 
-	return lines.join("\n");
+function statusEmoji(prIndex: number, currentIndex: number): string {
+	if (prIndex < currentIndex) return "✅";
+	return "⬜";
 }

package/src/telemetry/index.ts

@@ -0,0 +1,115 @@
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync } from "node:fs";
+
+const GA_ID = "G-L3SL6T6JQ1";
+const GA_SECRET = "Sier1nbXS2-eX2TR3j1kZQ";
+const MP_ENDPOINT = `https://www.google-analytics.com/mp/collect?measurement_id=${GA_ID}&api_secret=${GA_SECRET}`;
+
+const CONFIG_DIR = join(homedir(), ".newpr");
+const TELEMETRY_FILE = join(CONFIG_DIR, "telemetry.json");
+
+interface TelemetryConfig {
+	client_id: string;
+	consent: "granted" | "denied" | "pending";
+}
+
+let config: TelemetryConfig | null = null;
+
+function ensureDir(): void {
+	mkdirSync(CONFIG_DIR, { recursive: true });
+}
+
+async function loadConfig(): Promise<TelemetryConfig> {
+	if (config) return config;
+	try {
+		const file = Bun.file(TELEMETRY_FILE);
+		if (await file.exists()) {
+			const data = JSON.parse(await file.text()) as Partial<TelemetryConfig>;
+			config = {
+				client_id: data.client_id || randomUUID(),
+				consent: data.consent === "granted" || data.consent === "denied" ? data.consent : "pending",
+			};
+		} else {
+			config = { client_id: randomUUID(), consent: "pending" };
+		}
+	} catch {
+		config = { client_id: randomUUID(), consent: "pending" };
+	}
+	await saveConfig();
+	return config;
+}
+
+async function saveConfig(): Promise<void> {
+	if (!config) return;
+	ensureDir();
+	await Bun.write(TELEMETRY_FILE, `${JSON.stringify(config, null, 2)}\n`);
+}
+
+export async function getTelemetryConsent(): Promise<"granted" | "denied" | "pending"> {
+	const cfg = await loadConfig();
+	return cfg.consent;
+}
+
+export async function setTelemetryConsent(consent: "granted" | "denied"): Promise<void> {
+	const cfg = await loadConfig();
+	cfg.consent = consent;
+	await saveConfig();
+}
+
+async function sendEvents(events: Array<{ name: string; params?: Record<string, string | number | boolean> }>): Promise<void> {
+	const cfg = await loadConfig();
+	if (cfg.consent !== "granted") return;
+
+	const body = {
+		client_id: cfg.client_id,
+		events,
+	};
+
+	try {
+		await fetch(MP_ENDPOINT, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body),
+		});
+	} catch {
+		// Fire-and-forget — network failures are silent
+	}
+}
+
+function track(name: string, params?: Record<string, string | number | boolean>): void {
+	sendEvents([{ name, params }]);
+}
+
+export const telemetry = {
+	serverStarted: (version: string) =>
+		track("server_started", { version, platform: process.platform, arch: process.arch }),
+
+	analysisStarted: (fileCount: number) =>
+		track("analysis_started", { file_count: fileCount }),
+
+	analysisCompleted: (fileCount: number, durationSec: number) =>
+		track("analysis_completed", { file_count: fileCount, duration_sec: durationSec }),
+
+	analysisError: (errorType: string) =>
+		track("analysis_error", { error_type: errorType.slice(0, 100) }),
+
+	chatSent: () =>
+		track("chat_sent"),
+
+	chatCompleted: (durationSec: number, hasTools: boolean) =>
+		track("chat_completed", { duration_sec: durationSec, has_tools: hasTools }),
+
+	reviewSubmitted: (event: string) =>
+		track("review_submitted", { review_event: event }),
+
+	stackStarted: () =>
+		track("stack_started"),
+
+	stackCompleted: (groupCount: number) =>
+		track("stack_completed", { group_count: groupCount }),
+
+	stackPublished: (prCount: number) =>
+		track("stack_published", { pr_count: prCount }),
+};

package/src/web/client/App.tsx

@@ -202,6 +202,7 @@ export function App() {
 					onTabChange={handleTabChange}
 					onReanalyze={(prUrl: string) => { analysis.start(prUrl); }}
 					enabledPlugins={features.enabledPlugins}
+					onTrackAnalysis={bgAnalyses.track}
 				/>
 			)}
 			{analysis.phase === "error" && (

package/src/web/client/components/AnalyticsConsent.tsx

@@ -7,13 +7,23 @@ export function AnalyticsConsent({ onDone }: { onDone: () => void }) {
 
 	if (state !== "pending") return null;
 
+	const syncServer = (consent: "granted" | "denied") => {
+		fetch("/api/config", {
+			method: "PUT",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ telemetry_consent: consent }),
+		}).catch(() => {});
+	};
+
 	const handleAccept = () => {
 		setConsent("granted");
+		syncServer("granted");
 		onDone();
 	};
 
 	const handleDecline = () => {
 		setConsent("denied");
+		syncServer("denied");
 		onDone();
 	};
 

package/src/web/client/components/ResultsScreen.tsx

@@ -51,6 +51,7 @@ export function ResultsScreen({
 	onTabChange,
 	onReanalyze,
 	enabledPlugins,
+	onTrackAnalysis,
 }: {
 	data: NewprOutput;
 	onBack: () => void;
@@ -61,6 +62,7 @@ export function ResultsScreen({
 	onTabChange?: (tab: string) => void;
 	onReanalyze?: (prUrl: string) => void;
 	enabledPlugins?: string[];
+	onTrackAnalysis?: (analysisSessionId: string, prUrl: string) => void;
 }) {
 	const { meta, summary } = data;
 	const [tab, setTab] = useState<TabValue>(getInitialTab);
@@ -274,7 +276,7 @@ export function ResultsScreen({
 				/>
 			</TabsContent>
 			<TabsContent value="stack">
-				<StackPanel sessionId={sessionId} />
+				<StackPanel sessionId={sessionId} onTrackAnalysis={onTrackAnalysis} />
 			</TabsContent>
 			<TabsContent value="slides">
 				<SlidesPanel data={data} sessionId={sessionId} />

package/src/web/client/components/SettingsPanel.tsx

@@ -285,6 +285,11 @@ function AnalyticsToggle() {
 		setConsent(next);
 		setLocal(next);
 		analytics.settingsChanged("analytics");
+		fetch("/api/config", {
+			method: "PUT",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ telemetry_consent: next }),
+		}).catch(() => {});
 	};
 
 	return (

package/src/web/client/hooks/useStack.ts

@@ -133,7 +133,11 @@ function applyServerState(server: ServerStackState): Partial<StackState> {
 	};
 }
 
-export function useStack(sessionId: string | null | undefined) {
+interface UseStackOptions {
+	onTrackAnalysis?: (analysisSessionId: string, prUrl: string) => void;
+}
+
+export function useStack(sessionId: string | null | undefined, options?: UseStackOptions) {
 	const [state, setState] = useState<StackState>({
 		phase: "idle",
 		error: null,
@@ -253,11 +257,29 @@ export function useStack(sessionId: string | null | undefined) {
 			const data = await res.json();
 			if (!res.ok) throw new Error(data.error ?? "Publishing failed");
 
+			const publishResult = data.publish_result as PublishResultData;
+
 			setState((s) => ({
 				...s,
 				phase: "done",
-				publishResult: data.publish_result,
+				publishResult,
 			}));
+
+			if (options?.onTrackAnalysis && publishResult?.prs?.length > 0) {
+				for (const pr of publishResult.prs) {
+					try {
+						const analysisRes = await fetch("/api/analysis", {
+							method: "POST",
+							headers: { "Content-Type": "application/json" },
+							body: JSON.stringify({ pr: pr.url }),
+						});
+						const analysisData = await analysisRes.json() as { sessionId?: string };
+						if (analysisData.sessionId) {
+							options.onTrackAnalysis(analysisData.sessionId, pr.url);
+						}
+					} catch {}
+				}
+			}
 		} catch (err) {
 			setState((s) => ({
 				...s,
@@ -265,7 +287,7 @@ export function useStack(sessionId: string | null | undefined) {
 				error: err instanceof Error ? err.message : String(err),
 			}));
 		}
-	}, [sessionId]);
+	}, [sessionId, options]);
 
 	const reset = useCallback(() => {
 		eventSourceRef.current?.close();

package/src/web/client/panels/StackPanel.tsx

@@ -68,8 +68,13 @@ function PipelineTimeline({ phase }: { phase: StackPhase }) {
 	);
 }
 
-export function StackPanel({ sessionId }: { sessionId?: string | null }) {
-	const stack = useStack(sessionId);
+interface StackPanelProps {
+	sessionId?: string | null;
+	onTrackAnalysis?: (analysisSessionId: string, prUrl: string) => void;
+}
+
+export function StackPanel({ sessionId, onTrackAnalysis }: StackPanelProps) {
+	const stack = useStack(sessionId, { onTrackAnalysis });
 
 	if (stack.phase === "idle") {
 		return (

package/src/web/server/routes.ts

@@ -17,6 +17,7 @@ import { detectAgents, runAgent } from "../../workspace/agent.ts";
 import { randomBytes } from "node:crypto";
 import { publishStack } from "../../stack/publish.ts";
 import { startStack, getStackState, cancelStack, subscribeStack, restoreCompletedStacks } from "./stack-manager.ts";
+import { getTelemetryConsent, setTelemetryConsent, telemetry } from "../../telemetry/index.ts";
 
 function json(data: unknown, status = 200): Response {
 	return new Response(JSON.stringify(data), {
@@ -610,6 +611,7 @@ Before posting an inline comment, ALWAYS call \`get_file_diff\` first to find th
 			const pluginList = getAllPlugins().map((p) => ({ id: p.id, name: p.name }));
 			const enabledPlugins = stored.enabled_plugins ?? pluginList.map((p) => p.id);
 			const agents = await detectAgents();
+			const telemetryConsent = await getTelemetryConsent();
 			return json({
 				model: config.model,
 				agent: config.agent ?? null,
@@ -622,6 +624,7 @@ Before posting an inline comment, ALWAYS call \`get_file_diff\` first to find th
 				has_github_token: !!token,
 				enabled_plugins: enabledPlugins,
 				available_plugins: pluginList,
+				telemetry_consent: telemetryConsent,
 				defaults: {
 					model: DEFAULT_CONFIG.model,
 					language: DEFAULT_CONFIG.language,
@@ -673,6 +676,11 @@ Before posting an inline comment, ALWAYS call \`get_file_diff\` first to find th
 				update.enabled_plugins = (body as Record<string, unknown>).enabled_plugins as string[];
 			}
 
+			const telemetryConsentVal = (body as Record<string, unknown>).telemetry_consent as string | undefined;
+			if (telemetryConsentVal === "granted" || telemetryConsentVal === "denied") {
+				await setTelemetryConsent(telemetryConsentVal);
+			}
+
 			await writeStoredConfig(update);
 			return json({ ok: true });
 		},
@@ -748,6 +756,7 @@ Before posting an inline comment, ALWAYS call \`get_file_diff\` first to find th
 					return json({ error: errBody.message ?? `GitHub API error: ${res.status}` }, res.status);
 				}
 				const data = await res.json() as { id: number; state: string; html_url: string };
+				telemetry.reviewSubmitted(body.event);
 				return json({ ok: true, id: data.id, state: data.state, html_url: data.html_url });
 			} catch (err) {
 				return json({ error: err instanceof Error ? err.message : String(err) }, 500);

package/src/web/server/session-manager.ts

@@ -4,6 +4,7 @@ import type { ProgressEvent } from "../../analyzer/progress.ts";
 import { analyzePr } from "../../analyzer/pipeline.ts";
 import { parsePrInput } from "../../github/parse-pr.ts";
 import { saveSession, savePatchesSidecar } from "../../history/store.ts";
+import { telemetry } from "../../telemetry/index.ts";
 
 type SessionStatus = "running" | "done" | "error" | "canceled";
 
@@ -65,6 +66,7 @@ export function startAnalysis(
 	};
 	sessions.set(id, session);
 
+	telemetry.analysisStarted(0);
 	runPipeline(session, prInput, token, config);
 
 	return { sessionId: id };
@@ -100,6 +102,9 @@ async function runPipeline(
 		session.result = result;
 		session.finishedAt = Date.now();
 
+		const durationSec = Math.round((session.finishedAt - session.startedAt) / 1000);
+		telemetry.analysisCompleted(result.files?.length ?? 0, durationSec);
+
 		for (const sub of session.subscribers) {
 			sub({ type: "done" });
 		}
@@ -118,6 +123,8 @@ async function runPipeline(
 		session.error = msg;
 		session.finishedAt = Date.now();
 
+		telemetry.analysisError(msg);
+
 		for (const sub of session.subscribers) {
 			sub({ type: "error", data: msg });
 		}

package/src/web/server.ts

@@ -5,6 +5,7 @@ import index from "./index.html";
 
 import type { PreflightResult } from "../cli/preflight.ts";
 import { getVersion } from "../version.ts";
+import { telemetry } from "../telemetry/index.ts";
 
 interface WebServerOptions {
 	port: number;
@@ -211,6 +212,8 @@ export async function startWebServer(options: WebServerOptions): Promise<void> {
 
 	const url = `http://localhost:${server.port}`;
 
+	telemetry.serverStarted(getVersion());
+
 	const dim = (s: string) => `\x1b[2m${s}\x1b[0m`;
 	const bold = (s: string) => `\x1b[1m${s}\x1b[0m`;
 	const cyan = (s: string) => `\x1b[36m${s}\x1b[0m`;