newpr 1.0.17 → 1.0.18

package/package.json

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

package/src/llm/agent-client.ts

@@ -0,0 +1,53 @@
+import type { AgentToolName } from "../workspace/types.ts";
+import { getAvailableAgents, runAgentWithFallback } from "../workspace/agent.ts";
+import type { LlmClient, LlmResponse, StreamChunkCallback } from "./client.ts";
+
+function buildPrompt(systemPrompt: string, userPrompt: string): string {
+	return `<system>\n${systemPrompt}\n</system>\n\n${userPrompt}`;
+}
+
+export function createAgentLlmClient(timeoutSeconds: number, preferredAgent?: AgentToolName): LlmClient {
+	let agentsPromise: Promise<Awaited<ReturnType<typeof getAvailableAgents>>> | null = null;
+
+	const ensureAgents = async () => {
+		if (!agentsPromise) {
+			agentsPromise = getAvailableAgents(preferredAgent);
+		}
+		return agentsPromise;
+	};
+
+	const runComplete = async (systemPrompt: string, userPrompt: string): Promise<LlmResponse> => {
+		const agents = await ensureAgents();
+		const prompt = buildPrompt(systemPrompt, userPrompt);
+		const result = await runAgentWithFallback(agents, process.cwd(), prompt, {
+			timeout: timeoutSeconds * 1000,
+		});
+
+		const content = result.answer.trim();
+		if (!content) {
+			throw new Error("Agent returned empty response");
+		}
+
+		return {
+			content,
+			model: `agent:${result.tool_used}`,
+			usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+		};
+	};
+
+	return {
+		async complete(systemPrompt: string, userPrompt: string): Promise<LlmResponse> {
+			return runComplete(systemPrompt, userPrompt);
+		},
+
+		async completeStream(
+			systemPrompt: string,
+			userPrompt: string,
+			onChunk: StreamChunkCallback,
+		): Promise<LlmResponse> {
+			const response = await runComplete(systemPrompt, userPrompt);
+			onChunk(response.content, response.content);
+			return response;
+		},
+	};
+}

package/src/llm/resilient-client.ts

@@ -0,0 +1,79 @@
+import type { AgentToolName } from "../workspace/types.ts";
+import type { LlmClient, LlmClientOptions, LlmResponse, StreamChunkCallback } from "./client.ts";
+import { createLlmClient } from "./client.ts";
+import { createAgentLlmClient } from "./agent-client.ts";
+
+interface ResilientClientOptions {
+	preferredAgent?: AgentToolName;
+	onFallback?: (reason: string) => void;
+}
+
+function isOpenRouter401UserNotFound(error: unknown): boolean {
+	if (!(error instanceof Error)) return false;
+	return /OpenRouter API error\s*401/i.test(error.message) && /User not found/i.test(error.message);
+}
+
+function isOpenRouterJsonParseFailure(error: unknown): boolean {
+	if (!(error instanceof Error)) return false;
+	return /JSON Parse error/i.test(error.message)
+		|| /Unexpected token/i.test(error.message)
+		|| /Unterminated string/i.test(error.message);
+}
+
+export function createResilientLlmClient(
+	options: LlmClientOptions,
+	resilientOptions: ResilientClientOptions = {},
+): LlmClient {
+	const primary = createLlmClient(options);
+	let fallback: LlmClient | null = null;
+	let fallbackNotified = false;
+
+	const ensureFallback = (): LlmClient => {
+		if (!fallback) {
+			fallback = createAgentLlmClient(options.timeout, resilientOptions.preferredAgent);
+		}
+		return fallback;
+	};
+
+	const notifyFallback = (reason: string): void => {
+		if (fallbackNotified) return;
+		fallbackNotified = true;
+		resilientOptions.onFallback?.(reason);
+	};
+
+	const tryWithFallback = async (run: (client: LlmClient) => Promise<LlmResponse>): Promise<LlmResponse> => {
+		try {
+			return await run(primary);
+		} catch (error) {
+			if (!options.api_key) {
+				throw error;
+			}
+
+			if (isOpenRouter401UserNotFound(error)) {
+				notifyFallback("OpenRouter authentication failed (401 User not found)");
+				return run(ensureFallback());
+			}
+
+			if (isOpenRouterJsonParseFailure(error)) {
+				notifyFallback("OpenRouter response parsing failed");
+				return run(ensureFallback());
+			}
+
+			throw error;
+		}
+	};
+
+	return {
+		async complete(systemPrompt: string, userPrompt: string): Promise<LlmResponse> {
+			return tryWithFallback((client) => client.complete(systemPrompt, userPrompt));
+		},
+
+		async completeStream(
+			systemPrompt: string,
+			userPrompt: string,
+			onChunk: StreamChunkCallback,
+		): Promise<LlmResponse> {
+			return tryWithFallback((client) => client.completeStream(systemPrompt, userPrompt, onChunk));
+		},
+	};
+}

package/src/stack/balance.ts

@@ -1,6 +1,7 @@
 import type { LlmClient } from "../llm/client.ts";
 import type { FileGroup } from "../types/output.ts";
 import type { StackWarning } from "./types.ts";
+import { safeParseJson } from "./json-utils.ts";
 
 export interface BalanceResult {
 	ownership: Map<string, string>;
@@ -90,8 +91,9 @@ If no moves make sense, return: { "moves": [] }`;
 
 	try {
 		const response = await llmClient.complete(system, user);
-		const cleaned = response.content.replace(/```(?:json)?\s*/g, "").replace(/```\s*/g, "").trim();
-		const parsed = JSON.parse(cleaned) as { moves: Array<{ path: string; to: string; reason: string }> };
+		const result = safeParseJson<{ moves: Array<{ path: string; to: string; reason: string }> }>(response.content);
+		if (!result.ok) throw new Error(result.error);
+		const parsed = result.data;
 
 		const validGroupNames = new Set(groups.map((g) => g.name));
 

package/src/stack/json-utils.ts

@@ -0,0 +1,112 @@
+export type SafeParseResult<T = unknown> =
+	| { ok: true; data: T }
+	| { ok: false; error: string };
+
+function stripNonJsonArtifacts(raw: string): string {
+	return raw
+		.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "")
+		.replace(/[\u001b\u009b]/g, "")
+		.replace(/[\u2580-\u259F]/g, "")
+		.replace(/[^\x20-\x7E\u00A0-\uFFFF\n\r\t]/g, "");
+}
+
+function extractCodeBlock(text: string): string | null {
+	const match = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+	return match?.[1]?.trim() ?? null;
+}
+
+function findJsonBoundaries(source: string): string | null {
+	const objIdx = source.indexOf("{");
+	const arrIdx = source.indexOf("[");
+	let start = -1;
+	if (objIdx >= 0 && arrIdx >= 0) start = Math.min(objIdx, arrIdx);
+	else start = Math.max(objIdx, arrIdx);
+	if (start < 0) return null;
+
+	let inString = false;
+	let escaped = false;
+	const stack: string[] = [];
+
+	for (let i = start; i < source.length; i++) {
+		const ch = source[i]!;
+		if (inString) {
+			if (escaped) { escaped = false; continue; }
+			if (ch === "\\") { escaped = true; continue; }
+			if (ch === '"') inString = false;
+			continue;
+		}
+
+		if (ch === '"') { inString = true; continue; }
+		if (ch === "{" || ch === "[") { stack.push(ch); continue; }
+
+		if (ch === "}" || ch === "]") {
+			const top = stack[stack.length - 1];
+			if ((top === "{" && ch === "}") || (top === "[" && ch === "]")) {
+				stack.pop();
+				if (stack.length === 0) {
+					return source.slice(start, i + 1);
+				}
+			}
+		}
+	}
+
+	return null;
+}
+
+function repairTruncatedJson(text: string): string {
+	let depth = 0;
+	let inStr = false;
+	let esc = false;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i]!;
+		if (inStr) {
+			if (esc) { esc = false; continue; }
+			if (ch === "\\") { esc = true; continue; }
+			if (ch === '"') inStr = false;
+			continue;
+		}
+		if (ch === '"') { inStr = true; continue; }
+		if (ch === "{" || ch === "[") depth++;
+		if (ch === "}" || ch === "]") depth--;
+	}
+
+	let repaired = text;
+	if (inStr) repaired += '"';
+	while (depth > 0) {
+		repaired += "}";
+		depth--;
+	}
+	return repaired;
+}
+
+export function extractJsonFromText(raw: string): string {
+	const cleaned = stripNonJsonArtifacts(raw);
+
+	const fromBlock = extractCodeBlock(cleaned);
+	if (fromBlock) {
+		const bounded = findJsonBoundaries(fromBlock);
+		if (bounded) return bounded;
+		return fromBlock;
+	}
+
+	const bounded = findJsonBoundaries(cleaned);
+	if (bounded) return bounded;
+
+	return cleaned.trim();
+}
+
+export function safeParseJson<T = unknown>(raw: string): SafeParseResult<T> {
+	const extracted = extractJsonFromText(raw);
+
+	try {
+		return { ok: true, data: JSON.parse(extracted) as T };
+	} catch {
+	}
+
+	try {
+		const repaired = repairTruncatedJson(extracted);
+		return { ok: true, data: JSON.parse(repaired) as T };
+	} catch (err) {
+		return { ok: false, error: err instanceof Error ? err.message : String(err) };
+	}
+}

package/src/stack/partition.ts

@@ -2,6 +2,7 @@ import type { FileGroup } from "../types/output.ts";
 import type { PrCommit } from "../types/github.ts";
 import type { LlmClient } from "../llm/client.ts";
 import type { PartitionResult, ReattributedFile, StackWarning } from "./types.ts";
+import { safeParseJson } from "./json-utils.ts";
 
 interface FileSummaryInput {
 	path: string;
@@ -135,9 +136,36 @@ export async function partitionGroups(
 	);
 
 	const response = await client.complete(prompt.system, prompt.user);
-	const parsed = parsePartitionResponse(response.content, report, groups);
+	try {
+		return parsePartitionResponse(response.content, report, groups);
+	} catch {
+		const ownership = new Map(report.exclusive);
+		const fallbackGroup = groups[groups.length - 1]?.name;
+		if (fallbackGroup) {
+			for (const entry of report.ambiguous) {
+				ownership.set(entry.path, fallbackGroup);
+			}
+			for (const path of report.unassigned) {
+				ownership.set(path, fallbackGroup);
+			}
+		}
 
-	return parsed;
+		const affected = [...report.ambiguous.map((a) => a.path), ...report.unassigned];
+		return {
+			ownership,
+			reattributed: [],
+			warnings: [
+				`AI partition response could not be parsed; fallback assignment applied${fallbackGroup ? ` to "${fallbackGroup}"` : ""}`,
+			],
+			structured_warnings: [{
+				category: "system",
+				severity: "warn",
+				title: "AI partition parse failed; fallback assignment applied",
+				message: "Response contained non-JSON artifacts; ambiguous/unassigned files were auto-assigned",
+				details: affected,
+			}],
+		};
+	}
 }
 
 function parsePartitionResponse(
@@ -145,8 +173,9 @@ function parsePartitionResponse(
 	report: AmbiguityReport,
 	groups: FileGroup[],
 ): PartitionResult {
-	const jsonStr = extractJson(raw);
-	const parsed: unknown = JSON.parse(jsonStr);
+	const result = safeParseJson(raw);
+	if (!result.ok) throw new Error(`Partition parse failed: ${result.error}`);
+	const parsed: unknown = result.data;
 
 	if (!parsed || typeof parsed !== "object") {
 		throw new Error("Expected JSON object for partition response");
@@ -266,8 +295,4 @@ function parsePartitionResponse(
 	};
 }
 
-function extractJson(raw: string): string {
-	const codeBlockMatch = raw.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
-	if (codeBlockMatch?.[1]) return codeBlockMatch[1].trim();
-	return raw.trim();
-}
+

package/src/stack/pr-title.ts

@@ -1,5 +1,6 @@
 import type { LlmClient } from "../llm/client.ts";
 import type { StackGroup } from "./types.ts";
+import { safeParseJson } from "./json-utils.ts";
 
 const MAX_TITLE_LENGTH = 72;
 const KOREAN_NOUN_END_RE = /(추가|개선|수정|정리|분리|통합|구현|적용|도입|구성|지원|처리|보강|최적화|리팩터링|안정화|마이그레이션|업데이트|생성|검증|연동|변경|제거|작성|설정|관리|보호|강화|정의|확장|대응|복구|표시|유지|등록|삭제|작업)$/;
@@ -98,10 +99,12 @@ export async function generatePrTitles(
 ): Promise<Map<string, string>> {
 	const groupSummaries = groups
 		.map((g, i) => [
-			`Group ${i + 1}: "${g.name}"`,
-			`  Type: ${g.type}`,
-			`  Description: ${g.description}`,
-			`  Files (${g.files.length}): ${g.files.slice(0, 10).join(", ")}${g.files.length > 10 ? ` ... +${g.files.length - 10} more` : ""}`,
+			`Group ${i + 1}:`,
+			`  group_id: "${g.id}"`,
+			`  name: "${g.name}"`,
+			`  type: ${g.type}`,
+			`  description: ${g.description}`,
+			`  files (${g.files.length}): ${g.files.slice(0, 10).join(", ")}${g.files.length > 10 ? ` ... +${g.files.length - 10} more` : ""}`,
 		].join("\n"))
 		.join("\n\n");
 
@@ -144,33 +147,36 @@ Bad examples:
 - "feat: add JWT refresh middleware" (imperative verb)
 - "" (empty)
 
-Return ONLY a JSON array: [{"group_id": "...", "title": "..."}]`;
+IMPORTANT: The "group_id" in your response MUST exactly match the group_id value provided for each group. Do not use the group name or any other value.
+
+Return ONLY a JSON array: [{"group_id": "exact group_id from input", "title": "type: descriptive noun phrase"}]`;
 
 	const user = `Original PR: "${prTitle}"
 
 ${groupSummaries}
 
-Generate a descriptive PR title (40-72 chars) for each group. Return JSON array:
-[{"group_id": "...", "title": "..."}]`;
+Generate a unique, descriptive PR title (40-72 chars) for EACH group above. The group_id in your output must exactly match the group_id shown for each group.
+Return JSON array: [{"group_id": "...", "title": "..."}]`;
 
 	const response = await llmClient.complete(system, user);
 
 	const titles = new Map<string, string>();
 
+	const nameToId = new Map<string, string>();
+	for (const g of groups) {
+		nameToId.set(g.name.toLowerCase(), g.id);
+		nameToId.set(g.id.toLowerCase(), g.id);
+	}
+
 	try {
-		const cleaned = response.content.replace(/```(?:json)?\s*/g, "").replace(/```\s*/g, "").trim();
-		let parsed: Array<{ group_id: string; title: string }> = [];
-		try {
-			parsed = JSON.parse(cleaned) as Array<{ group_id: string; title: string }>;
-		} catch {
-			const arrayMatch = cleaned.match(/\[[\s\S]*\]/);
-			if (!arrayMatch) throw new Error("No JSON array found in response");
-			parsed = JSON.parse(arrayMatch[0]) as Array<{ group_id: string; title: string }>;
-		}
+		const result = safeParseJson<Array<{ group_id: string; title: string }>>(response.content);
+		if (!result.ok) throw new Error(result.error);
+		const parsed = result.data;
+		if (!Array.isArray(parsed)) throw new Error("Expected JSON array");
 		for (const item of parsed) {
-			if (item.group_id && item.title?.trim()) {
-				titles.set(item.group_id, sanitizeTitle(item.title, lang));
-			}
+			if (!item.group_id || !item.title?.trim()) continue;
+			const resolvedId = nameToId.get(item.group_id.toLowerCase()) ?? item.group_id;
+			titles.set(resolvedId, sanitizeTitle(item.title, lang));
 		}
 	} catch {
 		for (const g of groups) {