import type { EmbeddedContextFile } from "./pi-embedded-helpers.js";

import type { WorkspaceBootstrapFile } from "./workspace.js";

function extractBetween(

input: string,

startMarker: string,

endMarker: string,

): { text: string; found: boolean } {

type ToolReportEntry = SessionSystemPromptReport["tools"]["entries"][number];

const toolReportEntryCache = new WeakMap<AgentTool, ToolReportEntry>();

const toolSchemaStatsCache = new WeakMap<

object,

Pick<ToolReportEntry, "propertiesCount" | "schemaChars">

>();

function extractBetween(input: string, startMarker: string, endMarker: string): string {

const start = input.indexOf(startMarker);

if (start === -1) {

return { text: "", found: false };

return "";

}

const end = input.indexOf(endMarker, start + startMarker.length);

if (end === -1) {

return { text: input.slice(start), found: true };

}

return { text: input.slice(start, end), found: true };

return end === -1 ? input.slice(start) : input.slice(start, end);

}

function parseSkillBlocks(skillsPrompt: string): Array<{ name: string; blockChars: number }> {

.filter((b) => b.blockChars > 0);

}

function buildToolsEntries(tools: AgentTool[]): SessionSystemPromptReport["tools"]["entries"] {

return tools.map((tool) => {

const name = tool.name;

const summary = tool.description?.trim() || tool.label?.trim() || "";

const summaryChars = summary.length;

const schemaChars = (() => {

if (!tool.parameters || typeof tool.parameters !== "object") {

return 0;

}

function buildToolSchemaStats(

parameters: AgentTool["parameters"],

): Pick<ToolReportEntry, "propertiesCount" | "schemaChars"> {

if (!parameters || typeof parameters !== "object") {

return { schemaChars: 0, propertiesCount: null };

}

const cached = toolSchemaStatsCache.get(parameters);

if (cached) {

return cached;

}

const stats = {

schemaChars: (() => {

try {

return JSON.stringify(tool.parameters).length;

return JSON.stringify(parameters).length;

} catch {

return 0;

}

})();

const propertiesCount = (() => {

const schema =

tool.parameters && typeof tool.parameters === "object"

? (tool.parameters as Record<string, unknown>)

: null;

const props = schema && typeof schema.properties === "object" ? schema.properties : null;

})(),

propertiesCount: (() => {

const schema = parameters as Record<string, unknown>;

const props = typeof schema.properties === "object" ? schema.properties : null;

if (!props || typeof props !== "object") {

return null;

}

return Object.keys(props as Record<string, unknown>).length;

})();

return { name, summaryChars, schemaChars, propertiesCount };

})(),

};

toolSchemaStatsCache.set(parameters, stats);

return stats;

}

function buildToolsEntries(tools: AgentTool[]): SessionSystemPromptReport["tools"]["entries"] {

return tools.map((tool) => {

const cached = toolReportEntryCache.get(tool);

if (cached) {

return cached;

}

const name = tool.name;

const summary = tool.description?.trim() || tool.label?.trim() || "";

const summaryChars = summary.length;

const schemaStats = buildToolSchemaStats(tool.parameters);

const entry = { name, summaryChars, ...schemaStats };

toolReportEntryCache.set(tool, entry);

return entry;

});

}

function measureRenderedProjectContextChars(systemPrompt: string): number {

return extractBetween(systemPrompt, "\n# Project Context\n", "\n## Silent Replies\n").length;

}

export function buildSystemPromptReport(params: {

source: SessionSystemPromptReport["source"];

generatedAt: number;

skillsPrompt: string;

tools: AgentTool[];

}): SessionSystemPromptReport {

const systemPrompt = params.systemPrompt.trim();

const projectContext = extractBetween(

systemPrompt,

"\n# Project Context\n",

"\n## Silent Replies\n",

);

const projectContextChars = projectContext.text.length;

const systemPromptChars = params.systemPrompt.length;

const projectContextChars = measureRenderedProjectContextChars(params.systemPrompt);

const toolsEntries = buildToolsEntries(params.tools);

const toolsSchemaChars = toolsEntries.reduce((sum, t) => sum + (t.schemaChars ?? 0), 0);

const skillsEntries = parseSkillBlocks(params.skillsPrompt);

...(params.bootstrapTruncation ? { bootstrapTruncation: params.bootstrapTruncation } : {}),

sandbox: params.sandbox,

systemPrompt: {

chars: systemPrompt.length,

chars: systemPromptChars,

projectContextChars,

nonProjectContextChars: Math.max(0, systemPrompt.length - projectContextChars),

nonProjectContextChars: Math.max(0, systemPromptChars - projectContextChars),

},

injectedWorkspaceFiles: buildBootstrapInjectionStats({

bootstrapFiles: params.bootstrapFiles,