one-code-extension 0.1.0

package/extensions/branding/startup.ts

@@ -0,0 +1,152 @@
+/**
+ * Compact startup sections for the banner: Context, Skills, Themes.
+ *
+ * pi's own startup listing has no per-section switch — hiding the noisy
+ * [Extensions] block (20 internal module names) means `quietStartup: true`,
+ * which hides everything. So when quiet startup is on, the banner shows its
+ * own compact versions of the sections that ARE useful. pi's resourceLoader
+ * is not exposed to extensions, so these are re-derived the same way our
+ * other extensions derive them (claude-compat's skill dirs, pi's git-root
+ * context walk); pi-only extras such as the agent dir's skills/ are included
+ * for parity (the caller passes the live agent dir, which honours
+ * PI_CODING_AGENT_DIR isolation).
+ */
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
+import { findGitRoot } from "../lib/git.ts";
+import { discoverPlugins } from "../lib/plugins.ts";
+
+export interface StartupSection {
+	label: string;
+	items: string[];
+}
+
+/** CLAUDE.md / CLAUDE.local.md / AGENTS.md from cwd up to the git root (or just cwd outside a repo). */
+export function contextFileNames(cwd: string): string[] {
+	const stop = findGitRoot(cwd) ?? cwd;
+	const found: string[] = [];
+	let dir = cwd;
+	while (true) {
+		for (const name of ["CLAUDE.md", "CLAUDE.local.md", "AGENTS.md"]) {
+			const path = join(dir, name);
+			if (existsSync(path)) found.push(relative(cwd, path) || name);
+		}
+		if (dir === stop) break;
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return found;
+}
+
+/**
+ * Skills across the same sources our extensions feed to pi: project/user
+ * Claude Code dirs, pi's own user dir, and installed plugins. An entry counts
+ * when <dir>/<name>/SKILL.md exists — existsSync follows symlinked skill
+ * directories, which readdir's isDirectory() would miss.
+ */
+export function skillNames(cwd: string, home: string, agentDir: string): string[] {
+	const dirs = [
+		join(cwd, ".claude", "skills"),
+		join(home, ".claude", "skills"),
+		join(agentDir, "skills"),
+	];
+	const names = new Set<string>();
+	for (const dir of dirs) {
+		if (!existsSync(dir)) continue;
+		try {
+			for (const entry of readdirSync(dir)) {
+				if (existsSync(join(dir, entry, "SKILL.md"))) names.add(entry);
+			}
+		} catch {
+			// Unreadable dir: skip, same as pi would.
+		}
+	}
+	for (const skill of discoverPlugins(join(home, ".claude")).skills) {
+		names.add(skill.name);
+	}
+	return [...names].sort((a, b) => a.localeCompare(b));
+}
+
+/** Saved workflow names from the Claude Code layout dirs (project shadows user). */
+export function workflowNames(cwd: string, home: string): string[] {
+	const names = new Set<string>();
+	for (const dir of [join(cwd, ".claude", "workflows"), join(home, ".claude", "workflows")]) {
+		if (!existsSync(dir)) continue;
+		try {
+			for (const entry of readdirSync(dir)) {
+				if (entry.endsWith(".js") || entry.endsWith(".mjs")) names.add(entry.replace(/\.(js|mjs)$/, ""));
+			}
+		} catch {
+			// Unreadable dir: skip, same as pi would.
+		}
+	}
+	return [...names].sort((a, b) => a.localeCompare(b));
+}
+
+/** Theme names bundled with this package. */
+export function themeNames(packageThemesDir: string): string[] {
+	try {
+		return readdirSync(packageThemesDir)
+			.filter((f) => f.endsWith(".json"))
+			.map((f) => basename(f, ".json"))
+			.sort((a, b) => a.localeCompare(b));
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Whether One Code should default thinking blocks to collapsed (the Claude Code
+ * look: a one-line label, expanded on demand). Only when the user has never
+ * chosen: a `hideThinkingBlock` key in pi's global settings — written by
+ * ctrl+t, /settings, or a previous run of this default — is their decision and
+ * is never overridden. An unreadable settings file means "don't touch it".
+ */
+export function shouldDefaultHideThinking(settingsRaw: string | undefined): boolean {
+	if (settingsRaw === undefined) return true;
+	try {
+		const settings = JSON.parse(settingsRaw);
+		return !(settings && typeof settings === "object" && "hideThinkingBlock" in settings);
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Whether One Code should default pi's output padding to 0 — flush-left — so the
+ * assistant "●" marker (see `assistant-marker.ts`) lines up with the tool "●"
+ * bullets, which render at column 0. Same rule as the thinking default: only when
+ * the user has never set `outputPad` themselves (via `/settings` or a previous
+ * run of this default). An unreadable settings file means "don't touch it".
+ */
+export function shouldDefaultFlushOutputPad(settingsRaw: string | undefined): boolean {
+	if (settingsRaw === undefined) return true;
+	try {
+		const settings = JSON.parse(settingsRaw);
+		return !(settings && typeof settings === "object" && "outputPad" in settings);
+	} catch {
+		return false;
+	}
+}
+
+/** True when pi's own startup listing is silenced, so ours should render instead. */
+export function quietStartupEnabled(piSettingsPath: string): boolean {
+	try {
+		const settings = JSON.parse(readFileSync(piSettingsPath, "utf8"));
+		return settings?.quietStartup === true;
+	} catch {
+		return false;
+	}
+}
+
+export function collectStartupSections(cwd: string, home: string, packageThemesDir: string, agentDir: string): StartupSection[] {
+	const sections: StartupSection[] = [
+		{ label: "context", items: contextFileNames(cwd) },
+		{ label: "skills", items: skillNames(cwd, home, agentDir) },
+		{ label: "workflows", items: workflowNames(cwd, home) },
+		{ label: "themes", items: themeNames(packageThemesDir) },
+	];
+	return sections.filter((s) => s.items.length > 0);
+}

package/extensions/claude-compat/index.ts

@@ -0,0 +1,50 @@
+/**
+ * claude-compat extension — points pi's resource discovery at Claude Code's
+ * directory layout:
+ *
+ *   ~/.claude/skills, <project>/.claude/skills     → skills (same Agent Skills standard)
+ *   ~/.agents/skills, <project>/.agents/skills     → skills (the cross-tool Agent Skills
+ *                                                    directory, which Claude Code also reads)
+ *   ~/.claude/commands, <project>/.claude/commands → slash commands (prompt templates;
+ *                                                    Claude Code's $ARGUMENTS works as-is)
+ *
+ * CLAUDE.md needs no handling — pi discovers it natively alongside AGENTS.md.
+ */
+
+import { existsSync } from "node:fs";
+import os from "node:os";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { claudeConfigDir } from "../lib/paths.ts";
+
+/**
+ * `claudeDir` is Claude Code's config dir (honours CLAUDE_CONFIG_DIR), defaulting
+ * to `home/.claude`; `home` itself is used only for the unrelated
+ * `~/.agents/skills` cross-tool convention, which Claude Code does not relocate
+ * via that env var.
+ */
+export function claudeResourcePaths(
+	cwd: string,
+	home: string,
+	claudeDir: string = join(home, ".claude"),
+): { skillPaths: string[]; promptPaths: string[] } {
+	const candidates = {
+		skillPaths: [
+			join(claudeDir, "skills"),
+			join(home, ".agents", "skills"),
+			join(cwd, ".claude", "skills"),
+			join(cwd, ".agents", "skills"),
+		],
+		promptPaths: [join(claudeDir, "commands"), join(cwd, ".claude", "commands")],
+	};
+	return {
+		skillPaths: candidates.skillPaths.filter((p) => existsSync(p)),
+		promptPaths: candidates.promptPaths.filter((p) => existsSync(p)),
+	};
+}
+
+export default function claudeCompatExtension(pi: ExtensionAPI) {
+	pi.on("resources_discover", (event) => {
+		return claudeResourcePaths(event.cwd, os.homedir(), claudeConfigDir());
+	});
+}

package/extensions/claude-context/index.ts

@@ -0,0 +1,79 @@
+/**
+ * claude-context extension — assembles Claude Code's `# claudeMd` context block
+ * (CLAUDE.md files + MEMORY.md index + userEmail + currentDate) and injects it as
+ * a `<system-reminder>` at the front of the first user message, matching Claude
+ * Code byte-for-byte (see extensions/lib/claude-context.ts for the format).
+ *
+ * The block is emitted `first-prepend` at CONTEXT_ORDER.claudeMd — last in Claude
+ * Code's context stack (deferred tools → agents → MCP → skills → claudeMd), just
+ * before the user's text. It rides the reminder queue (transient per-request via
+ * pi's `context` event), so it never persists to the session and never doubles up
+ * on resume.
+ *
+ * Paths are re-derived from home/cwd here rather than shared with the memory
+ * extension (jiti gives each extension its own module instance). CLAUDE.md is no
+ * longer put in the system prompt, and MEMORY.md is no longer a separate reminder
+ * — both fold into this one block, as Claude Code does.
+ */
+
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import os from "node:os";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { buildClaudeMdBlock, discoverContextFiles } from "../lib/claude-context.ts";
+import { projectMemoryDir, truncateIndex } from "../lib/memory.ts";
+import { claudeConfigDir } from "../lib/paths.ts";
+import { CONTEXT_ORDER, REMINDER_CHANNEL } from "../lib/reminders.ts";
+
+const REMINDER_KEY = "claude-context";
+
+/** The account email Claude Code stamps as `# userEmail`. git config is our proxy. */
+function resolveEmail(cwd: string): string | null {
+	try {
+		const email = execFileSync("git", ["config", "user.email"], { cwd, encoding: "utf8" }).trim();
+		if (email) return email;
+	} catch {
+		// no git / no config — fall through
+	}
+	return process.env.GIT_AUTHOR_EMAIL?.trim() || process.env.EMAIL?.trim() || null;
+}
+
+function readMemoryIndex(cwd: string): { path: string; content: string } | null {
+	const dir = projectMemoryDir(cwd, os.homedir());
+	const path = join(dir, "MEMORY.md");
+	try {
+		const raw = readFileSync(path, "utf8");
+		if (!raw.trim()) return null;
+		return { path, content: truncateIndex(raw) };
+	} catch {
+		return null;
+	}
+}
+
+export default function claudeContextExtension(pi: ExtensionAPI) {
+	pi.on("session_start", (_event, ctx) => {
+		const inner = buildClaudeMdBlock({
+			contextFiles: discoverContextFiles({
+				cwd: ctx.cwd,
+				homeClaudeDir: claudeConfigDir(),
+			}),
+			memoryIndex: readMemoryIndex(ctx.cwd),
+			email: resolveEmail(ctx.cwd),
+			// Per-session date, matching the cached Environment section; Claude Code's
+			// block changes only across days too.
+			date: new Date().toISOString().slice(0, 10),
+		});
+		if (!inner) return;
+
+		pi.events.emit(REMINDER_CHANNEL, {
+			text: inner,
+			scope: "every-turn",
+			key: REMINDER_KEY,
+			placement: "first-prepend",
+			order: CONTEXT_ORDER.claudeMd,
+			// Claude Code's claudeMd block ends `</system-reminder>\n\n` on the wire.
+			suffix: "\n\n",
+		});
+	});
+}

package/extensions/compaction/index.ts

@@ -0,0 +1,231 @@
+/**
+ * compaction extension — replaces pi's summarizer with Claude Code's.
+ *
+ * Hooks `session_before_compact` (manual /compact, threshold, and overflow
+ * alike), reuses pi's already-computed cut point, and sends Claude Code's
+ * compaction instruction; only the <summary> block of the reply survives as
+ * context.
+ *
+ * The call is built to hit the provider prompt cache, which is why Claude
+ * Code compacts on the *session model* rather than something cheaper: it
+ * keeps the session's system prompt, tools, and message prefix intact and
+ * merely appends the instruction, so the summarization call is mostly cache
+ * reads. Same here — session model, session system prompt, the active tool
+ * definitions, and, crucially, the session's *last actual request messages*
+ * (captured from the `context` event, see below), with the instruction riding
+ * as a final user message of <system-reminder> blocks.
+ *
+ * A cache hit needs the whole request to match the session's, so the call also
+ * replays two request options the naive shape got wrong:
+ *   - `reasoning`: mirrors the session's thinking level. On the Responses API the
+ *     reasoning config is part of the prompt-cache identity — a byte-identical
+ *     prefix still misses without it (measured). Safe where the classifier's
+ *     cross-model reasoning trade is not: it is the session's own model, already
+ *     proven to accept the level, and pi clamps an unsupported level down.
+ *   - On Anthropic, the context-management beta + `clear_thinking` body edit that
+ *     the session's requests carry (added by the context-management extension via
+ *     hooks completeSimple bypasses). Without them the session caches its message
+ *     prefix thinking-cleared while this call sends full thinking blocks, and the
+ *     mismatch invalidates the message-block cache (system+tools still read).
+ *
+ * Any failure returns nothing, so pi's own compaction serves — a different
+ * summary style, never a broken compaction. CC_COMPACTION=0 opts out.
+ */
+
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { Api, Model, Tool } from "@earendil-works/pi-ai";
+import { completeSimple } from "@earendil-works/pi-ai/compat";
+import {
+	convertToLlm,
+	type ExtensionAPI,
+	type SessionBeforeCompactEvent,
+} from "@earendil-works/pi-coding-agent";
+import {
+	type AnthropicModelCompat,
+	anthropicBetas,
+	clearThinkingApplies,
+	clearThinkingEnabled,
+	isAnthropicOAuth,
+	looksLikeAnthropicRequest,
+	withClearThinking,
+} from "../context-management/index.ts";
+import { buildCompactionInstruction, COMPACTION_MAX_TOKENS, continuationSummary, extractSummary } from "./prompt.ts";
+
+/** Compaction reads a whole context window; give it more room than the classifier's 30s. */
+const COMPACTION_TIMEOUT_MS = 120_000;
+
+export default function compactionExtension(pi: ExtensionAPI) {
+	/**
+	 * The exact message array the session last handed the provider, captured
+	 * from the `context` event AFTER every extension has mutated it — most
+	 * importantly system-reminder, which injects <system-reminder> blocks at
+	 * request time (memory index, the every-turn subagent-models reminder, …).
+	 *
+	 * Byte-matching the prefix is necessary for the cache but not sufficient (the
+	 * `reasoning` and, on Anthropic, `clear_thinking` options below must match too).
+	 * pi's agent loop builds a request by applying `transformContext` (this very
+	 * event) and then `convertToLlm` (agent-loop.ts); we call the *same*
+	 * `convertToLlm` on the captured array, so the message prefix we send is
+	 * byte-identical to the turn's, and appending only the instruction keeps that
+	 * whole prefix reusable. Reconstructing from session entries instead (the
+	 * fallback) diverges at message one, because those injected reminders never
+	 * become entries — so it cannot reproduce the cached prefix at all.
+	 *
+	 * We hold the reference, not a copy: `emitContext` hands each handler a fresh
+	 * structuredClone the session never mutates again, and compaction is the
+	 * last extension with a `context` handler, so this reference is exactly the
+	 * array the turn sent. Returning nothing keeps the handler a pure observer.
+	 */
+	let capturedMessages: AgentMessage[] | undefined;
+	pi.on("context", (event) => {
+		capturedMessages = event.messages;
+	});
+
+	pi.on("session_before_compact", async (event, ctx) => {
+		if (process.env.CC_COMPACTION === "0") return undefined;
+
+		const model = ctx.model;
+		if (!model) return undefined;
+
+		try {
+			const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+			if (!auth.ok) return undefined;
+			const baseUrl = (auth as { baseUrl?: string }).baseUrl;
+
+			// Prefer the captured request prefix — it is cache-aligned and already
+			// carries the leading compactionSummary message on a re-compaction.
+			// Fall back to reconstructing from session entries only when nothing
+			// has been captured yet (e.g. /compact as the first action in a freshly
+			// resumed session, before any turn ran); that path cannot hit the cache.
+			const messages = capturedMessages ?? reconstructFromEntries(event.preparation);
+
+			const instruction = buildCompactionInstruction({
+				reason: event.reason,
+				customInstructions: event.customInstructions,
+			});
+
+			// The active tool definitions, in their active order — kept in the
+			// request purely so the cached prefix (tools come first) still matches.
+			// A mismatch costs cache hits, never correctness.
+			const byName = new Map(pi.getAllTools().map((tool) => [tool.name, tool]));
+			const tools = pi
+				.getActiveTools()
+				.map((name) => byName.get(name))
+				.filter((tool) => tool !== undefined)
+				.map(({ name, description, parameters }) => ({ name, description, parameters }) as Tool);
+
+			// When context-management (clear_thinking) is active for this session,
+			// the agent loop's cached message prefix has old thinking blocks cleared
+			// and every request carries the context-management beta. completeSimple
+			// bypasses our before_provider_headers/before_provider_request handlers,
+			// so the compaction request would omit both — and on Anthropic that
+			// mismatch invalidates the *message* cache (system+tools still read, but
+			// the whole history re-caches; measured cacheRead ~13k of ~56k). Replay
+			// the same beta header and clear_thinking body edit so the replayed
+			// prefix matches the session's cache and the history stays a cache read.
+			// No-op off Anthropic (clearThinkingEnabled is false there), where
+			// automatic prefix caching needs neither.
+			// model.compat is a provider union; the clear_thinking helpers only read
+			// the Anthropic-shaped fields, and are gated to Anthropic anyway.
+			const cmModel = model as { api?: string; provider?: string; baseUrl?: string; compat?: AnthropicModelCompat };
+			const clearThinking = clearThinkingEnabled(process.env.CC_CLEAR_THINKING, cmModel);
+			const headers = clearThinking
+				? { ...auth.headers, "anthropic-beta": anthropicBetas(isAnthropicOAuth(), cmModel.compat) }
+				: auth.headers;
+
+			const timeout = AbortSignal.timeout(COMPACTION_TIMEOUT_MS);
+			const result = await completeSimple(
+				baseUrl ? ({ ...model, baseUrl } as Model<Api>) : model,
+				{
+					systemPrompt: ctx.getSystemPrompt(),
+					messages: [...convertToLlm(messages), { role: "user", content: instruction, timestamp: Date.now() }],
+					tools,
+				},
+				{
+					apiKey: auth.apiKey,
+					headers,
+					env: auth.env,
+					signal: AbortSignal.any([event.signal, timeout]),
+					maxTokens: Math.min(COMPACTION_MAX_TOKENS, model.maxTokens || COMPACTION_MAX_TOKENS),
+					// The session id is the prompt-cache key / routing affinity on the
+					// providers that use one (openai-codex prompt_cache_key, session
+					// headers). Without it the replayed prefix cannot hit the session's
+					// cache no matter how well the bytes match.
+					sessionId: ctx.sessionManager.getSessionId(),
+					// Reasoning config is part of the cache identity on the Responses
+					// API: with a byte-identical prefix, prompt_cache_key, tools, and
+					// system prompt, omitting `reasoning` on a reasoning-configured
+					// session still misses the cache entirely (measured: cacheRead 0).
+					// Mirror the session's own thinking level so the request matches
+					// the prefix the session cached. Unlike the auto-mode classifier —
+					// which may run a *different*, unvalidated model where reasoning
+					// fails closed — this is the session's own model, already proven to
+					// accept this level, and streamSimple clamps an unsupported level
+					// down rather than erroring, so mirroring never fails closed here.
+					// "off" carries no reasoning (matching what such a session sends).
+					reasoning: ctx.thinkingLevel === "off" ? undefined : ctx.thinkingLevel,
+					// The clear_thinking body edit, matching the session's requests (see
+					// the header note above). Only attached on Anthropic requests that
+					// carry thinking, exactly as the context-management extension gates it.
+					onPayload: clearThinking
+						? (payload: unknown) =>
+								looksLikeAnthropicRequest(payload) &&
+								clearThinkingApplies(payload as Record<string, unknown>, cmModel.compat?.forceAdaptiveThinking === true)
+									? withClearThinking(payload as Record<string, unknown>)
+									: payload
+						: undefined,
+				},
+			);
+
+			const text = result.content
+				.filter((block): block is { type: "text"; text: string } => block.type === "text")
+				.map((block) => block.text)
+				.join("\n");
+			const summary = extractSummary(text);
+			if (!summary) return undefined;
+
+			return {
+				compaction: {
+					// Undefined in --no-session runs; the pointer line is dropped.
+					summary: continuationSummary(summary, ctx.sessionManager.getSessionFile()),
+					firstKeptEntryId: event.preparation.firstKeptEntryId,
+					tokensBefore: event.preparation.tokensBefore,
+					usage: result.usage,
+				},
+			};
+		} catch {
+			// pi's default compaction runs instead: degraded style, never broken.
+			return undefined;
+		}
+	});
+}
+
+/**
+ * Fallback message construction from session entries, used only when no live
+ * request was captured. This cannot hit the prompt cache (the request-time
+ * <system-reminder> injections are absent from entries), but it still yields a
+ * correct summary — and if it fails, pi's own compaction serves.
+ *
+ * A previous compaction's summary is excluded from messagesToSummarize
+ * (prepareCompaction starts after that entry), yet the live context carries it
+ * as its leading compactionSummary message. Reattach it in exactly that shape so
+ * convertToLlm renders the same bytes the session's context holds. A split
+ * turn's discarded prefix has no separate summary on this path, so it is
+ * summarized with the rest.
+ */
+function reconstructFromEntries(preparation: SessionBeforeCompactEvent["preparation"]): AgentMessage[] {
+	const doomed = preparation.isSplitTurn
+		? [...preparation.messagesToSummarize, ...preparation.turnPrefixMessages]
+		: preparation.messagesToSummarize;
+	return preparation.previousSummary
+		? [
+				{
+					role: "compactionSummary",
+					summary: preparation.previousSummary,
+					tokensBefore: 0,
+					timestamp: Date.now(),
+				} as AgentMessage,
+				...doomed,
+			]
+		: doomed;
+}