pi-oxidized 0.1.1

package/.references/pi/scripts/session-transcripts.ts

@@ -0,0 +1,406 @@
+#!/usr/bin/env node
+/**
+ * Extracts session transcripts for a given cwd, splits into context-sized files,
+ * optionally spawns subagents to analyze patterns.
+ *
+ * Usage: node scripts/session-transcripts.ts [--analyze] [--output <dir>] [cwd]
+ *   --analyze      Spawn pi subagents to analyze each transcript file
+ *   --output <dir> Output directory for transcript files (defaults to ./session-transcripts)
+ *   cwd            Working directory to extract sessions for (defaults to current)
+ */
+
+import { readFileSync, readdirSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { spawn } from "child_process";
+import { createInterface } from "node:readline";
+import { homedir } from "os";
+import { join, resolve } from "path";
+import { parseSessionEntries, type SessionMessageEntry } from "../packages/coding-agent/src/core/session-manager.ts";
+import chalk from "chalk";
+
+const MAX_CHARS_PER_FILE = 100_000; // ~20k tokens, leaving room for prompt + analysis + output
+
+function cwdToSessionDir(cwd: string): string {
+	const normalized = resolve(cwd).replace(/\//g, "-");
+	return `--${normalized.slice(1)}--`; // Remove leading slash, wrap with --
+}
+
+function extractTextContent(content: string | Array<{ type: string; text?: string }>): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+
+	return content
+		.filter((c) => c.type === "text" && c.text)
+		.map((c) => c.text!)
+		.join("\n");
+}
+
+function parseSession(filePath: string): string[] {
+	const content = readFileSync(filePath, "utf8");
+	const entries = parseSessionEntries(content);
+	const messages: string[] = [];
+
+	for (const entry of entries) {
+		if (entry.type !== "message") continue;
+		const msgEntry = entry as SessionMessageEntry;
+		const { role, content } = msgEntry.message;
+
+		if (role !== "user" && role !== "assistant") continue;
+
+		const text = extractTextContent(content as string | Array<{ type: string; text?: string }>);
+		if (!text.trim()) continue;
+
+		messages.push(`[${role.toUpperCase()}]\n${text}`);
+	}
+
+	return messages;
+}
+
+const MAX_DISPLAY_WIDTH = 100;
+
+function truncateLine(text: string, maxWidth: number): string {
+	const singleLine = text.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
+	if (singleLine.length <= maxWidth) return singleLine;
+	return singleLine.slice(0, maxWidth - 3) + "...";
+}
+
+interface JsonEvent {
+	type: string;
+	assistantMessageEvent?: { type: string; delta?: string };
+	toolName?: string;
+	args?: {
+		path?: string;
+		offset?: number;
+		limit?: number;
+		content?: string;
+	};
+}
+
+function runSubagent(prompt: string, cwd: string): Promise<{ success: boolean }> {
+	return new Promise((resolve) => {
+		const child = spawn("pi", ["--mode", "json", "--tools", "read,write", "-p", prompt], {
+			cwd,
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+
+		let textBuffer = "";
+
+		const rl = createInterface({ input: child.stdout });
+
+		rl.on("line", (line) => {
+			try {
+				const event: JsonEvent = JSON.parse(line);
+
+				if (event.type === "message_update" && event.assistantMessageEvent) {
+					const msgEvent = event.assistantMessageEvent;
+					if (msgEvent.type === "text_delta" && msgEvent.delta) {
+						textBuffer += msgEvent.delta;
+					}
+				} else if (event.type === "tool_execution_start" && event.toolName) {
+					// Print accumulated text before tool starts
+					if (textBuffer.trim()) {
+						console.log(chalk.dim("  " + truncateLine(textBuffer, MAX_DISPLAY_WIDTH)));
+						textBuffer = "";
+					}
+					// Format tool call with args
+					let argsStr = "";
+					if (event.args) {
+						if (event.toolName === "read") {
+							argsStr = event.args.path || "";
+							if (event.args.offset) argsStr += ` offset=${event.args.offset}`;
+							if (event.args.limit) argsStr += ` limit=${event.args.limit}`;
+						} else if (event.toolName === "write") {
+							argsStr = event.args.path || "";
+						}
+					}
+					console.log(chalk.cyan(`  [${event.toolName}] ${argsStr}`));
+				} else if (event.type === "turn_end") {
+					// Print any remaining text at turn end
+					if (textBuffer.trim()) {
+						console.log(chalk.dim("  " + truncateLine(textBuffer, MAX_DISPLAY_WIDTH)));
+					}
+					textBuffer = "";
+				}
+			} catch {
+				// Ignore malformed JSON
+			}
+		});
+
+		child.stderr.on("data", (data) => {
+			process.stderr.write(chalk.red(data.toString()));
+		});
+
+		child.on("close", (code) => {
+			resolve({ success: code === 0 });
+		});
+
+		child.on("error", (err) => {
+			console.error(chalk.red(`  Failed to spawn pi: ${err.message}`));
+			resolve({ success: false });
+		});
+	});
+}
+
+async function main() {
+	const args = process.argv.slice(2);
+	const analyzeFlag = args.includes("--analyze");
+
+	// Parse --output <dir>
+	const outputIdx = args.indexOf("--output");
+	let outputDir = resolve("./session-transcripts");
+	if (outputIdx !== -1 && args[outputIdx + 1]) {
+		outputDir = resolve(args[outputIdx + 1]);
+	}
+
+	// Find cwd (positional arg that's not a flag or flag value)
+	const flagIndices = new Set<number>();
+	flagIndices.add(args.indexOf("--analyze"));
+	if (outputIdx !== -1) {
+		flagIndices.add(outputIdx);
+		flagIndices.add(outputIdx + 1);
+	}
+	const cwdArg = args.find((a, i) => !flagIndices.has(i) && !a.startsWith("--"));
+	const cwd = resolve(cwdArg || process.cwd());
+
+	mkdirSync(outputDir, { recursive: true });
+	const sessionsBase = join(homedir(), ".pi/agent/sessions");
+	const sessionDirName = cwdToSessionDir(cwd);
+	const sessionDir = join(sessionsBase, sessionDirName);
+
+	if (!existsSync(sessionDir)) {
+		console.error(`No sessions found for ${cwd}`);
+		console.error(`Expected: ${sessionDir}`);
+		process.exit(1);
+	}
+
+	const sessionFiles = readdirSync(sessionDir)
+		.filter((f) => f.endsWith(".jsonl"))
+		.sort();
+
+	console.log(`Found ${sessionFiles.length} session files in ${sessionDir}`);
+
+	// Collect all transcripts
+	const allTranscripts: string[] = [];
+	for (const file of sessionFiles) {
+		const filePath = join(sessionDir, file);
+		const messages = parseSession(filePath);
+		if (messages.length > 0) {
+			allTranscripts.push(`=== SESSION: ${file} ===\n${messages.join("\n---\n")}\n=== END SESSION ===`);
+		}
+	}
+
+	if (allTranscripts.length === 0) {
+		console.error("No transcripts found");
+		process.exit(1);
+	}
+
+	// Split into files respecting MAX_CHARS_PER_FILE
+	const outputFiles: string[] = [];
+	let currentContent = "";
+	let fileIndex = 0;
+
+	for (const transcript of allTranscripts) {
+		// If adding this transcript would exceed limit, write current and start new
+		if (currentContent.length > 0 && currentContent.length + transcript.length + 2 > MAX_CHARS_PER_FILE) {
+			const filename = `session-transcripts-${String(fileIndex).padStart(3, "0")}.txt`;
+			writeFileSync(join(outputDir, filename), currentContent);
+			outputFiles.push(filename);
+			console.log(`Wrote ${filename} (${currentContent.length} chars)`);
+			currentContent = "";
+			fileIndex++;
+		}
+
+		// If this single transcript exceeds limit, write it to its own file
+		if (transcript.length > MAX_CHARS_PER_FILE) {
+			// Write any pending content first
+			if (currentContent.length > 0) {
+				const filename = `session-transcripts-${String(fileIndex).padStart(3, "0")}.txt`;
+				writeFileSync(join(outputDir, filename), currentContent);
+				outputFiles.push(filename);
+				console.log(`Wrote ${filename} (${currentContent.length} chars)`);
+				currentContent = "";
+				fileIndex++;
+			}
+			// Write the large transcript to its own file
+			const filename = `session-transcripts-${String(fileIndex).padStart(3, "0")}.txt`;
+			writeFileSync(join(outputDir, filename), transcript);
+			outputFiles.push(filename);
+			console.log(chalk.yellow(`Wrote ${filename} (${transcript.length} chars) - oversized`));
+			fileIndex++;
+			continue;
+		}
+
+		currentContent += (currentContent ? "\n\n" : "") + transcript;
+	}
+
+	// Write remaining content
+	if (currentContent.length > 0) {
+		const filename = `session-transcripts-${String(fileIndex).padStart(3, "0")}.txt`;
+		writeFileSync(join(outputDir, filename), currentContent);
+		outputFiles.push(filename);
+		console.log(`Wrote ${filename} (${currentContent.length} chars)`);
+	}
+
+	console.log(`\nCreated ${outputFiles.length} transcript file(s) in ${outputDir}`);
+
+	if (!analyzeFlag) {
+		console.log("\nRun with --analyze to spawn pi subagents for pattern analysis.");
+		return;
+	}
+
+	// Find AGENTS.md files to compare against
+	const globalAgentsMd = join(homedir(), ".pi/agent/AGENTS.md");
+	const localAgentsMd = join(cwd, "AGENTS.md");
+	const agentsMdFiles = [globalAgentsMd, localAgentsMd].filter(existsSync);
+	const agentsMdSection =
+		agentsMdFiles.length > 0
+			? `STEP 1: Read the existing AGENTS.md file(s) to see what's already encoded:\n${agentsMdFiles.join("\n")}\n\nSTEP 2: `
+			: "";
+
+	// Spawn subagents to analyze each file
+	const analysisPrompt = `You are analyzing session transcripts to identify recurring user instructions that could be automated.
+
+${agentsMdSection}READING THE TRANSCRIPT:
+The transcript file is large. Read it in chunks of 1000 lines using offset/limit parameters:
+1. First: read with limit=1000 (lines 1-1000)
+2. Then: read with offset=1001, limit=1000 (lines 1001-2000)
+3. Continue incrementing offset by 1000 until you reach the end
+4. Only after reading the ENTIRE file, perform the analysis and write the summary
+
+ANALYSIS TASK:
+Look for patterns where the user repeatedly gives similar instructions. These could become:
+- AGENTS.md entries: coding style rules, behavior guidelines, project conventions
+- Skills: multi-step workflows with external tools (search, browser, APIs)
+- Prompt templates: reusable prompts for common tasks
+
+Compare each pattern against the existing AGENTS.md content to determine if it's NEW or EXISTING.
+
+OUTPUT FORMAT (strict):
+Write a file with exactly this structure. Use --- as separator between patterns.
+
+PATTERN: <short descriptive name>
+STATUS: NEW | EXISTING
+TYPE: agents-md | skill | prompt-template
+FREQUENCY: <number of times observed>
+EVIDENCE:
+- "<exact quote 1>"
+- "<exact quote 2>"
+- "<exact quote 3>"
+DRAFT:
+<proposed content for AGENTS.md entry, SKILL.md, or prompt template>
+---
+
+Rules:
+- Only include patterns that appear 2+ times
+- STATUS is NEW if not in AGENTS.md, EXISTING if already covered
+- EVIDENCE must contain exact quotes from the transcripts
+- DRAFT must be ready-to-use content
+- If no patterns found, write "NO PATTERNS FOUND"
+- Do not include any other text outside this format`;
+
+	console.log("\nSpawning subagents for analysis...");
+	for (const file of outputFiles) {
+		const summaryFile = file.replace(".txt", ".summary.txt");
+		const filePath = join(outputDir, file);
+		const summaryPath = join(outputDir, summaryFile);
+
+		const fileContent = readFileSync(filePath, "utf8");
+		const fileSize = fileContent.length;
+
+		console.log(`Analyzing ${file} (${fileSize} chars)...`);
+
+		const lineCount = fileContent.split("\n").length;
+		const fullPrompt = `${analysisPrompt}\n\nThe file ${filePath} has ${lineCount} lines. Read it in full using chunked reads, then write your analysis to ${summaryPath}`;
+
+		const result = await runSubagent(fullPrompt, outputDir);
+
+		if (result.success && existsSync(summaryPath)) {
+			console.log(chalk.green(`  -> ${summaryFile}`));
+		} else if (result.success) {
+			console.error(chalk.yellow(`  Agent finished but did not write ${summaryFile}`));
+		} else {
+			console.error(chalk.red(`  Failed to analyze ${file}`));
+		}
+	}
+
+	// Collect all created summary files
+	const summaryFiles = readdirSync(outputDir)
+		.filter((f) => f.endsWith(".summary.txt"))
+		.sort();
+
+	console.log(`\n=== Individual Analysis Complete ===`);
+	console.log(`Created ${summaryFiles.length} summary files`);
+
+	if (summaryFiles.length === 0) {
+		console.log(chalk.yellow("No summary files created. Nothing to aggregate."));
+		return;
+	}
+
+	// Final aggregation step
+	console.log("\nAggregating findings into final summary...");
+
+	const summaryPaths = summaryFiles.map((f) => join(outputDir, f)).join("\n");
+	const finalSummaryPath = join(outputDir, "FINAL-SUMMARY.txt");
+
+	const aggregationPrompt = `You are aggregating pattern analysis results from multiple summary files.
+
+STEP 1: Read the existing AGENTS.md file(s) to understand what patterns are already encoded:
+${agentsMdFiles.length > 0 ? agentsMdFiles.join("\n") : "(no AGENTS.md files found)"}
+
+STEP 2: Read ALL of the following summary files:
+${summaryPaths}
+
+STEP 3: Create a consolidated final summary that:
+1. Merges duplicate patterns (same pattern found in multiple files)
+2. Ranks patterns by total frequency across all files
+3. Groups by status (NEW first, then EXISTING) and type
+4. Provides the best/most complete DRAFT for each unique pattern
+5. Verify STATUS against AGENTS.md content (pattern may be marked NEW in summaries but actually exists)
+
+OUTPUT FORMAT (strict):
+Write the final summary with this structure:
+
+# NEW PATTERNS (not yet in AGENTS.md)
+
+## AGENTS.MD: <pattern name>
+Total Frequency: <sum across all files>
+Evidence:
+- "<best quotes>"
+Draft:
+<consolidated draft>
+
+## SKILL: <pattern name>
+...
+
+## PROMPT-TEMPLATE: <pattern name>
+...
+
+---
+
+# EXISTING PATTERNS (already in AGENTS.md, for reference)
+
+## <pattern name>
+Total Frequency: <N>
+Already covered by: <quote relevant section from AGENTS.md>
+
+---
+
+# SUMMARY
+- New patterns to add: <N>
+- Already covered: <N>
+- Top 3 new patterns by frequency: <list>
+
+Write the final summary to ${finalSummaryPath}`;
+
+	const aggregateResult = await runSubagent(aggregationPrompt, outputDir);
+
+	if (aggregateResult.success && existsSync(finalSummaryPath)) {
+		console.log(chalk.green(`\n=== Final Summary Created ===`));
+		console.log(chalk.green(`  ${finalSummaryPath}`));
+	} else if (aggregateResult.success) {
+		console.error(chalk.yellow(`Agent finished but did not write final summary`));
+	} else {
+		console.error(chalk.red(`Failed to create final summary`));
+	}
+}
+
+main().catch(console.error);

package/.references/pi/scripts/stats.ts

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+interface UsageCost {
+	input?: number;
+	output?: number;
+	cacheRead?: number;
+	cacheWrite?: number;
+	total?: number;
+}
+
+interface Usage {
+	input?: number;
+	output?: number;
+	cacheRead?: number;
+	cacheWrite?: number;
+	totalTokens?: number;
+	cost?: UsageCost;
+}
+
+interface AssistantMessage {
+	role?: string;
+	provider?: string;
+	usage?: Usage;
+	timestamp?: number;
+}
+
+interface SessionEntry {
+	type?: string;
+	timestamp?: string;
+	message?: AssistantMessage;
+}
+
+interface Totals {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	totalTokens: number;
+	costInput: number;
+	costOutput: number;
+	costCacheRead: number;
+	costCacheWrite: number;
+	costTotal: number;
+	assistantMessages: number;
+	sessions: Set<string>;
+}
+
+interface DayStats extends Totals {
+	providers: Map<string, Totals>;
+}
+
+interface Args {
+	days: number;
+	cwd: string;
+	sessionsBase: string;
+}
+
+function createTotals(): Totals {
+	return {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		costInput: 0,
+		costOutput: 0,
+		costCacheRead: 0,
+		costCacheWrite: 0,
+		costTotal: 0,
+		assistantMessages: 0,
+		sessions: new Set<string>(),
+	};
+}
+
+function createDayStats(): DayStats {
+	return {
+		...createTotals(),
+		providers: new Map<string, Totals>(),
+	};
+}
+
+function addUsage(totals: Totals, usage: Usage, sessionFile: string): void {
+	const cost = usage.cost ?? {};
+	totals.input += usage.input ?? 0;
+	totals.output += usage.output ?? 0;
+	totals.cacheRead += usage.cacheRead ?? 0;
+	totals.cacheWrite += usage.cacheWrite ?? 0;
+	totals.totalTokens += usage.totalTokens ?? 0;
+	totals.costInput += cost.input ?? 0;
+	totals.costOutput += cost.output ?? 0;
+	totals.costCacheRead += cost.cacheRead ?? 0;
+	totals.costCacheWrite += cost.cacheWrite ?? 0;
+	totals.costTotal += cost.total ?? 0;
+	totals.assistantMessages += 1;
+	totals.sessions.add(sessionFile);
+}
+
+function encodeSessionDir(cwd: string): string {
+	const normalized = cwd.startsWith("/") ? cwd.slice(1) : cwd;
+	return `--${normalized.replace(/\//g, "-")}--`;
+}
+
+function localDayKey(date: Date): string {
+	const year = date.getFullYear();
+	const month = String(date.getMonth() + 1).padStart(2, "0");
+	const day = String(date.getDate()).padStart(2, "0");
+	return `${year}-${month}-${day}`;
+}
+
+function parseArgs(): Args {
+	const args = process.argv.slice(2);
+	let days = 7;
+	let cwd = process.cwd();
+	let sessionsBase = join(homedir(), ".pi", "agent", "sessions");
+
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if ((arg === "--days" || arg === "-n") && args[i + 1]) {
+			days = Number.parseInt(args[++i], 10);
+		} else if ((arg === "--cwd" || arg === "--dir" || arg === "-d") && args[i + 1]) {
+			cwd = resolve(args[++i]);
+		} else if (arg === "--sessions-base" && args[i + 1]) {
+			sessionsBase = resolve(args[++i]);
+		} else if (arg === "--help" || arg === "-h") {
+			console.log(`Usage: scripts/stats.ts [options]
+
+Options:
+  -n, --days <days>         Number of local calendar days to include (default: 7)
+  -d, --dir, --cwd <path>   Project cwd to inspect (default: current cwd)
+  --sessions-base <path>    Sessions base directory (default: ~/.pi/agent/sessions)
+  -h, --help                Show this help`);
+			process.exit(0);
+		}
+	}
+
+	if (!Number.isInteger(days) || days <= 0) {
+		throw new Error("--days must be a positive integer");
+	}
+
+	return { days, cwd: resolve(cwd), sessionsBase };
+}
+
+function formatInt(value: number): string {
+	return Math.round(value).toLocaleString("en-US");
+}
+
+function formatCost(value: number): string {
+	return `$${value.toFixed(4)}`;
+}
+
+function printTotals(label: string, totals: Totals): void {
+	console.log(
+		`${label.padEnd(16)} messages: ${String(totals.assistantMessages).padStart(5)}  sessions: ${String(totals.sessions.size).padStart(3)}  ` +
+			`input: ${formatInt(totals.input).padStart(12)}  output: ${formatInt(totals.output).padStart(10)}  ` +
+			`cache read: ${formatInt(totals.cacheRead).padStart(13)}  cache write: ${formatInt(totals.cacheWrite).padStart(10)}  ` +
+			`total: ${formatInt(totals.totalTokens).padStart(13)}  cost: ${formatCost(totals.costTotal).padStart(10)}`,
+	);
+}
+
+const { days, cwd, sessionsBase } = parseArgs();
+const sessionsDir = join(sessionsBase, encodeSessionDir(cwd));
+
+if (!existsSync(sessionsDir)) {
+	throw new Error(`Sessions directory not found: ${sessionsDir}`);
+}
+
+const now = new Date();
+const start = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+start.setDate(start.getDate() - days + 1);
+const end = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
+
+const stats = new Map<string, DayStats>();
+const grandTotal = createTotals();
+
+for (const file of readdirSync(sessionsDir)) {
+	if (!file.endsWith(".jsonl")) continue;
+
+	const path = join(sessionsDir, file);
+	const lines = readFileSync(path, "utf8").split("\n");
+	for (const line of lines) {
+		if (!line.trim()) continue;
+
+		let entry: SessionEntry;
+		try {
+			entry = JSON.parse(line) as SessionEntry;
+		} catch {
+			continue;
+		}
+
+		if (entry.type !== "message" || entry.message?.role !== "assistant" || !entry.message.usage) continue;
+
+		const timestamp = entry.message.timestamp !== undefined ? new Date(entry.message.timestamp) : new Date(entry.timestamp ?? 0);
+		if (timestamp < start || timestamp >= end) continue;
+
+		const dayKey = localDayKey(timestamp);
+		let dayStats = stats.get(dayKey);
+		if (!dayStats) {
+			dayStats = createDayStats();
+			stats.set(dayKey, dayStats);
+		}
+
+		const provider = entry.message.provider ?? "unknown";
+		let providerStats = dayStats.providers.get(provider);
+		if (!providerStats) {
+			providerStats = createTotals();
+			dayStats.providers.set(provider, providerStats);
+		}
+
+		addUsage(dayStats, entry.message.usage, file);
+		addUsage(providerStats, entry.message.usage, file);
+		addUsage(grandTotal, entry.message.usage, file);
+	}
+}
+
+console.log(`Usage for ${cwd}`);
+console.log(`Sessions: ${sessionsDir}`);
+console.log(`Period: ${localDayKey(start)} through ${localDayKey(new Date(end.getTime() - 1))} (${days} local days)`);
+console.log("".padEnd(160, "="));
+
+for (const day of [...stats.keys()].sort()) {
+	const dayStats = stats.get(day)!;
+	printTotals(day, dayStats);
+	for (const provider of [...dayStats.providers.keys()].sort()) {
+		printTotals(`  ${provider}`, dayStats.providers.get(provider)!);
+	}
+}
+
+console.log("".padEnd(160, "-"));
+printTotals("TOTAL", grandTotal);