@mrclrchtr/supi-context 0.1.0

package/src/format.ts

@@ -0,0 +1,280 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { ContextAnalysis } from "./analysis.ts";
+import { formatTokens, pluralize } from "./utils.ts";
+
+const GRID_COLS = 20;
+const GRID_ROWS = 5;
+const GRID_BLOCKS = GRID_COLS * GRID_ROWS;
+
+type CategoryKey =
+  | "systemPrompt"
+  | "userMessages"
+  | "assistantMessages"
+  | "toolCalls"
+  | "toolResults"
+  | "other";
+
+const CATEGORY_ORDER: CategoryKey[] = [
+  "systemPrompt",
+  "userMessages",
+  "assistantMessages",
+  "toolCalls",
+  "toolResults",
+  "other",
+];
+
+const CATEGORY_LABELS: Record<CategoryKey, string> = {
+  systemPrompt: "System prompt",
+  userMessages: "User messages",
+  assistantMessages: "Assistant messages",
+  toolCalls: "Tool calls",
+  toolResults: "Tool results",
+  other: "Other",
+};
+
+const CATEGORY_COLORS: Record<CategoryKey, Parameters<Theme["fg"]>["0"]> = {
+  systemPrompt: "accent",
+  userMessages: "success",
+  assistantMessages: "warning",
+  toolCalls: "error",
+  toolResults: "dim",
+  other: "muted",
+};
+
+function pct(value: number, total: number): string {
+  if (total <= 0) return "0.0%";
+  return `${((value / total) * 100).toFixed(1)}%`;
+}
+
+function padLeft(text: string, width: number): string {
+  return text.padStart(width, " ");
+}
+
+function padRight(text: string, width: number): string {
+  return text.padEnd(width, " ");
+}
+
+function allocateGridBlocks(segments: number[]): number[] {
+  const total = segments.reduce((sum, value) => sum + value, 0);
+  if (total <= 0) {
+    return segments.map(() => 0);
+  }
+
+  const exact = segments.map((value) => (value / total) * GRID_BLOCKS);
+  const counts = exact.map((value) => Math.floor(value));
+  const remaining = GRID_BLOCKS - counts.reduce((sum, value) => sum + value, 0);
+
+  const byRemainder = exact
+    .map((value, index) => ({ index, remainder: value - counts[index] }))
+    .sort((a, b) => b.remainder - a.remainder);
+
+  for (let i = 0; i < remaining; i++) {
+    counts[byRemainder[i]?.index ?? 0] += 1;
+  }
+
+  return counts;
+}
+
+function renderGrid(analysis: ContextAnalysis, theme: Theme): string[] {
+  const { contextWindow, categories } = analysis;
+  if (contextWindow <= 0) {
+    return [theme.fg("dim", "No model selected — grid unavailable")];
+  }
+
+  const segments = [
+    ...CATEGORY_ORDER.map((key) => ({
+      color: CATEGORY_COLORS[key],
+      tokens: categories[key],
+      block: "█",
+    })),
+    { color: "dim" as Parameters<Theme["fg"]>["0"], tokens: categories.freeSpace, block: "░" },
+    {
+      color: "warning" as Parameters<Theme["fg"]>["0"],
+      tokens: categories.autocompactBuffer,
+      block: "░",
+    },
+  ];
+
+  const counts = allocateGridBlocks(segments.map((segment) => segment.tokens));
+  const blocks: string[] = [];
+  for (const [index, segment] of segments.entries()) {
+    for (let i = 0; i < (counts[index] ?? 0); i++) {
+      blocks.push(theme.fg(segment.color, segment.block));
+    }
+  }
+
+  const gridLines: string[] = [];
+  for (let row = 0; row < GRID_ROWS; row++) {
+    const start = row * GRID_COLS;
+    const line = blocks.slice(start, start + GRID_COLS).join("");
+    gridLines.push(line);
+  }
+
+  // Model info on the right
+  const infoLines = [
+    theme.fg("text", analysis.modelName),
+    theme.fg("dim", `${formatTokens(contextWindow)} context window`),
+    theme.fg(
+      "text",
+      `${formatTokens(analysis.totalTokens ?? 0)} used (${pct(analysis.totalTokens ?? 0, contextWindow)})`,
+    ),
+  ];
+
+  if (analysis.approximationNote) {
+    infoLines.push(theme.fg("warning", analysis.approximationNote));
+  }
+
+  const combined: string[] = [];
+  for (let i = 0; i < GRID_ROWS; i++) {
+    const left = gridLines[i] ?? "";
+    const right = infoLines[i] ?? "";
+    combined.push(`${left}  ${right}`);
+  }
+  // Append any remaining info lines if grid is shorter (shouldn't happen with 5 rows)
+  for (let i = GRID_ROWS; i < infoLines.length; i++) {
+    combined.push(`${" ".repeat(GRID_COLS + 2)}${infoLines[i]}`);
+  }
+
+  return combined;
+}
+
+function renderCategoryBreakdown(analysis: ContextAnalysis, theme: Theme): string[] {
+  const lines: string[] = [];
+  lines.push(theme.fg("accent", "Usage by category"));
+
+  const { contextWindow, categories } = analysis;
+  const allCategories: Array<{
+    key: CategoryKey | "autocompactBuffer" | "freeSpace";
+    label: string;
+    color: Parameters<Theme["fg"]>["0"];
+    tokens: number;
+  }> = [
+    ...CATEGORY_ORDER.map((key) => ({
+      key,
+      label: CATEGORY_LABELS[key],
+      color: CATEGORY_COLORS[key],
+      tokens: categories[key],
+    })),
+    {
+      key: "autocompactBuffer",
+      label: "Autocompact buffer",
+      color: "warning" as Parameters<Theme["fg"]>["0"],
+      tokens: categories.autocompactBuffer,
+    },
+    {
+      key: "freeSpace",
+      label: "Free space",
+      color: "dim" as Parameters<Theme["fg"]>["0"],
+      tokens: categories.freeSpace,
+    },
+  ];
+
+  for (const cat of allCategories) {
+    if (cat.tokens <= 0 && cat.key !== "freeSpace") continue;
+    const label = padRight(cat.label, 20);
+    const tokens = padLeft(formatTokens(cat.tokens), 8);
+    const percentage = padLeft(pct(cat.tokens, contextWindow), 7);
+    lines.push(`${theme.fg(cat.color, "●")} ${label} ${tokens} ${percentage}`);
+  }
+
+  return lines;
+}
+
+function renderContextFilesSection(analysis: ContextAnalysis, theme: Theme): string[] {
+  const files = analysis.systemPromptBreakdown.contextFiles;
+  if (files.length === 0) return [];
+
+  const lines: string[] = [];
+  lines.push("");
+  lines.push(theme.fg("accent", "Context Files (system prompt)"));
+  for (const f of files) {
+    lines.push(`  ${theme.fg("text", f.path)}  ${theme.fg("dim", formatTokens(f.tokens))}`);
+  }
+  return lines;
+}
+
+function renderInjectedFilesSection(analysis: ContextAnalysis, theme: Theme): string[] {
+  const files = analysis.injectedFiles;
+  if (files.length === 0) return [];
+
+  const lines: string[] = [];
+  lines.push("");
+  lines.push(theme.fg("accent", "Context Files (injected · supi-claude-md)"));
+  for (const f of files) {
+    lines.push(
+      `  ${theme.fg("text", f.file)}  ${theme.fg("dim", formatTokens(f.tokens))}  ${theme.fg("dim", `turn ${f.turn}`)}`,
+    );
+  }
+  return lines;
+}
+
+function renderSkillsSection(analysis: ContextAnalysis, theme: Theme): string[] {
+  const lines: string[] = [];
+  lines.push("");
+  lines.push(theme.fg("accent", `Skills (${analysis.skills.length})`));
+
+  if (analysis.skills.length === 0) {
+    lines.push(theme.fg("dim", "  Send a message to see skill details"));
+    return lines;
+  }
+
+  for (const s of analysis.skills) {
+    lines.push(`  ${theme.fg("text", s.name)}  ${theme.fg("dim", formatTokens(s.tokens))}`);
+  }
+  return lines;
+}
+
+function renderGuidelinesAndTools(analysis: ContextAnalysis, theme: Theme): string[] {
+  const lines: string[] = [];
+  lines.push("");
+  lines.push(
+    `${theme.fg("text", "Guidelines")}  ${theme.fg("dim", formatTokens(analysis.guidelines))}`,
+  );
+  lines.push(
+    `${theme.fg("text", `Tool Definitions (${analysis.toolDefinitions.count} active)`)}  ${theme.fg("dim", formatTokens(analysis.toolDefinitions.tokens))}`,
+  );
+  return lines;
+}
+
+function renderCompactionNote(analysis: ContextAnalysis, theme: Theme): string[] {
+  if (!analysis.compaction) return [];
+  return [
+    "",
+    theme.fg(
+      "dim",
+      `↳ ${pluralize(analysis.compaction.summarizedTurns, "older turn", "older turns")} summarized (compaction)`,
+    ),
+  ];
+}
+
+function renderProviderSections(analysis: ContextAnalysis, theme: Theme): string[] {
+  if (analysis.providerSections.length === 0) return [];
+
+  const lines: string[] = [];
+  for (const section of analysis.providerSections) {
+    lines.push("");
+    lines.push(theme.fg("accent", section.label));
+    for (const [key, value] of Object.entries(section.data)) {
+      lines.push(`  ${theme.fg("text", key)}: ${theme.fg("dim", String(value))}`);
+    }
+  }
+  return lines;
+}
+
+export function formatContextReport(analysis: ContextAnalysis, theme: Theme): string[] {
+  const lines: string[] = [];
+
+  lines.push(theme.fg("accent", "◆ Context Usage"));
+  lines.push("");
+  lines.push(...renderGrid(analysis, theme));
+  lines.push("");
+  lines.push(...renderCategoryBreakdown(analysis, theme));
+  lines.push(...renderContextFilesSection(analysis, theme));
+  lines.push(...renderInjectedFilesSection(analysis, theme));
+  lines.push(...renderSkillsSection(analysis, theme));
+  lines.push(...renderGuidelinesAndTools(analysis, theme));
+  lines.push(...renderCompactionNote(analysis, theme));
+  lines.push(...renderProviderSections(analysis, theme));
+
+  return lines;
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { default } from "./context.ts";

package/src/prompt-inference.ts

@@ -0,0 +1,131 @@
+import { existsSync, readFileSync } from "node:fs";
+import type {
+  BuildSystemPromptOptions,
+  ExtensionCommandContext,
+  Skill,
+} from "@earendil-works/pi-coding-agent";
+
+function unescapeXml(text: string): string {
+  return text
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&amp;/g, "&");
+}
+
+function isLikelyContextFileHeading(value: string): boolean {
+  return (
+    value.includes("/") ||
+    value.includes("\\") ||
+    value.startsWith("~") ||
+    /(?:^|\b)(?:AGENTS|CLAUDE|SYSTEM|APPEND_SYSTEM)\.md$/i.test(value)
+  );
+}
+
+function deriveSkills(systemPrompt: string): Skill[] {
+  const skills: Skill[] = [];
+  const skillRegex =
+    /<skill>\s*<name>([\s\S]*?)<\/name>\s*<description>([\s\S]*?)<\/description>\s*<location>([\s\S]*?)<\/location>\s*<\/skill>/g;
+
+  for (const match of systemPrompt.matchAll(skillRegex)) {
+    skills.push({
+      name: unescapeXml(match[1].trim()),
+      description: unescapeXml(match[2].trim()),
+      filePath: unescapeXml(match[3].trim()),
+    } as Skill);
+  }
+
+  return skills;
+}
+
+function sliceProjectContextSection(systemPrompt: string): string | null {
+  const sectionMarker = "\n\n# Project Context\n\n";
+  const projectContextStart = systemPrompt.indexOf(sectionMarker);
+  if (projectContextStart < 0) {
+    return null;
+  }
+
+  let projectContext = systemPrompt.slice(projectContextStart + sectionMarker.length);
+  const intro = "Project-specific instructions and guidelines:\n\n";
+  if (projectContext.startsWith(intro)) {
+    projectContext = projectContext.slice(intro.length);
+  }
+
+  const skillsMarker =
+    "\n\nThe following skills provide specialized instructions for specific tasks.";
+  const skillsIndex = projectContext.indexOf(skillsMarker);
+  if (skillsIndex >= 0) {
+    projectContext = projectContext.slice(0, skillsIndex);
+  }
+
+  const dateIndex = projectContext.indexOf("\nCurrent date: ");
+  if (dateIndex >= 0) {
+    projectContext = projectContext.slice(0, dateIndex);
+  }
+
+  return projectContext;
+}
+
+function deriveContextFiles(systemPrompt: string): Array<{ path: string; content: string }> {
+  const projectContext = sliceProjectContextSection(systemPrompt);
+  if (!projectContext) {
+    return [];
+  }
+
+  const contextFiles: Array<{ path: string; content: string }> = [];
+  const headingRegex = /^##\s+(.+)$/gm;
+  for (const match of projectContext.matchAll(headingRegex)) {
+    const filePath = match[1].trim();
+    if (!isLikelyContextFileHeading(filePath) || !existsSync(filePath)) {
+      continue;
+    }
+    contextFiles.push({ path: filePath, content: readFileSync(filePath, "utf-8") });
+  }
+
+  return contextFiles;
+}
+
+export function extractGuidelinesSection(systemPrompt: string): string | null {
+  const marker = "\nGuidelines:\n";
+  const start = systemPrompt.indexOf(marker);
+  if (start < 0) {
+    return null;
+  }
+
+  const afterStart = start + marker.length;
+  const endMarkers = ["\n\nPi documentation", "\n\n# Project Context", "\nCurrent date: "];
+  let end = systemPrompt.length;
+  for (const endMarker of endMarkers) {
+    const index = systemPrompt.indexOf(endMarker, afterStart);
+    if (index >= 0) {
+      end = Math.min(end, index);
+    }
+  }
+
+  const section = systemPrompt.slice(afterStart, end).trim();
+  return section.length > 0 ? section : null;
+}
+
+export function deriveOptionsFromSystemPrompt(
+  ctx: ExtensionCommandContext,
+  cachedOptions: BuildSystemPromptOptions | undefined,
+): BuildSystemPromptOptions | undefined {
+  if (cachedOptions) {
+    return cachedOptions;
+  }
+
+  const systemPrompt = ctx.getSystemPrompt();
+  const contextFiles = deriveContextFiles(systemPrompt);
+  const skills = deriveSkills(systemPrompt);
+
+  if (contextFiles.length === 0 && skills.length === 0) {
+    return undefined;
+  }
+
+  return {
+    cwd: ctx.cwd,
+    contextFiles,
+    skills,
+  };
+}

package/src/renderer.ts

@@ -0,0 +1,26 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
+import type { ContextAnalysis } from "./analysis.ts";
+import { formatContextReport } from "./format.ts";
+
+export function registerContextRenderer(pi: ExtensionAPI): void {
+  pi.registerMessageRenderer("supi-context", (message, _renderOptions, theme) => {
+    const analysis = (message.details as { analysis?: ContextAnalysis } | undefined)?.analysis;
+    if (!analysis) {
+      return new Text(theme.fg("dim", "No context analysis data"), 1, 0);
+    }
+
+    const lines = formatContextReport(analysis, theme);
+    const container = new Container();
+
+    for (const line of lines) {
+      if (line === "") {
+        container.addChild(new Spacer(1));
+      } else {
+        container.addChild(new Text(line, 0, 0));
+      }
+    }
+
+    return container;
+  });
+}

package/src/utils.ts

@@ -0,0 +1,15 @@
+/**
+ * Format a token count for display (e.g. 45231 → "45.2k").
+ */
+export function formatTokens(tokens: number): string {
+  if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(1)}M`;
+  if (tokens >= 1_000) return `${(tokens / 1_000).toFixed(1)}k`;
+  return `${tokens}`;
+}
+
+/**
+ * Simple pluralize helper.
+ */
+export function pluralize(count: number, singular: string, plural: string): string {
+  return count === 1 ? `${count} ${singular}` : `${count} ${plural}`;
+}