one-code-extension 0.4.1 → 0.5.0

package/extensions/branding/prompt-editor.ts

@@ -3,14 +3,19 @@
  *
  * pi's editor has no prompt marker and no option for one, but `CustomEditor` is
  * the sanctioned base for a replacement (it already wires every app keybinding
- * through handleInput, which we leave untouched). We only reserve a two-column
- * left gutter and paint the marker into it — see prompt-marker.ts for why that
- * is cursor-safe. Registered via `ctx.ui.setEditorComponent`; this file is thin
+ * through handleInput). We reserve a two-column left gutter and paint the
+ * marker into it — see prompt-marker.ts for why that is cursor-safe — draw a
+ * slash command's argument hint after the cursor (lib/argument-hints.ts), and
+ * let ↑ restore queued messages through pi's dequeue action (queued-edit.ts). Registered via `ctx.ui.setEditorComponent`; this file is thin
  * wiring over the pure `applyPromptMarker`.
  */
 
 import { CustomEditor } from "@earendil-works/pi-coding-agent";
+import { applyBorderBadge, fitBadge } from "../lib/agent-view.ts";
+import { applyArgumentHint } from "../lib/argument-hints.ts";
+import { visibleWidth } from "../lib/text-width.ts";
 import { applyPromptMarker } from "./prompt-marker.ts";
+import { upEditsQueue } from "./queued-edit.ts";
 
 /** Width of the left gutter, and therefore the visible width the marker must fill. */
 export const PROMPT_PADDING = 2;
@@ -20,10 +25,45 @@ type EditorArgs = ConstructorParameters<typeof CustomEditor>;
 export class PromptEditor extends CustomEditor {
 	/** Re-read per render so the marker follows live theme changes. */
 	#renderMarker: () => string;
+	/** The painted argument placeholder for the current input, if it is a hinted command. */
+	#renderHint: (text: string) => string | undefined;
+	/** The viewed agent's top-border label (plain text), or undefined on main (lib/agent-view.ts). */
+	#badge: () => string | undefined;
+	/** Paints the fitted badge label as a chip, one space of padding on each side. */
+	#paintBadge: (label: string) => string;
+	/** Whether a message waits in pi's queue mid-turn (queued-edit.ts). */
+	#queued: () => boolean;
+	#keys: EditorArgs[2];
+	/** The width pi wraps the text at, from the last render (pi's own formula). */
+	#layoutWidth = Number.POSITIVE_INFINITY;
 
-	constructor(tui: EditorArgs[0], theme: EditorArgs[1], keybindings: EditorArgs[2], renderMarker: () => string) {
-		super(tui, theme, keybindings, { paddingX: PROMPT_PADDING });
+	constructor(
+		tui: EditorArgs[0],
+		theme: EditorArgs[1],
+		keybindings: EditorArgs[2],
+		renderMarker: () => string,
+		renderHint: (text: string) => string | undefined = () => undefined,
+		badge: () => string | undefined = () => undefined,
+		paintBadge: (label: string) => string = (label) => label,
+		queued: () => boolean = () => false,
+	) {
+		super(tui, theme, keybindings, { paddingX: PROMPT_PADDING, embedWorkingStatus: true });
 		this.#renderMarker = renderMarker;
+		this.#renderHint = renderHint;
+		this.#badge = badge;
+		this.#paintBadge = paintBadge;
+		this.#queued = queued;
+		this.#keys = keybindings;
+	}
+
+	/** ↑ on the first line restores queued messages, as in Claude Code (queued-edit.ts). */
+	handleInput(data: string): void {
+		const dequeue = this.actionHandlers.get("app.message.dequeue");
+		if (dequeue && this.#keys.matches(data, "tui.editor.cursorUp") && upEditsQueue(this, this.#queued(), this.#layoutWidth)) {
+			dequeue();
+			return;
+		}
+		super.handleInput(data);
 	}
 
 	/**
@@ -37,6 +77,13 @@ export class PromptEditor extends CustomEditor {
 	}
 
 	render(width: number): string[] {
-		return applyPromptMarker(super.render(width), PROMPT_PADDING, this.#renderMarker());
+		const paddingX = Math.min(PROMPT_PADDING, Math.max(0, Math.floor((width - 1) / 2)));
+		this.#layoutWidth = Math.max(1, width - paddingX * 2 - (paddingX ? 0 : 1));
+		let lines = applyPromptMarker(super.render(width), PROMPT_PADDING, this.#renderMarker());
+		const hint = this.#renderHint(this.getText());
+		if (hint) lines = applyArgumentHint(lines, hint);
+		const label = this.#badge();
+		const fitted = label ? fitBadge(label, width) : "";
+		return fitted ? applyBorderBadge(lines, this.#paintBadge(fitted), visibleWidth(fitted) + 2, this.borderColor("─")) : lines;
 	}
 }

package/extensions/branding/queued-edit.ts

@@ -0,0 +1,31 @@
+/**
+ * Claude Code's key for editing queued messages: plain ↑. With a message
+ * queued mid-turn, ↑ moves every queued message into the editor instead of
+ * walking history, but only with the cursor on the draft's first line (lower
+ * lines need ↑ to move the cursor) and no autocomplete list open (↑ moves in
+ * the list). pi binds the same restore only to alt+up, which not every
+ * terminal sends: macOS Terminal's terminfo (nsterm) maps option+left and
+ * option+right but no modified up arrow. Pure: `prompt-editor.ts` calls pi's
+ * own dequeue action, so the alt+up binding keeps working alongside.
+ */
+
+import { visibleWidth } from "../lib/text-width.ts";
+
+export interface QueueEditEditor {
+	getCursor(): { line: number; col: number };
+	getLines(): string[];
+	isShowingAutocomplete(): boolean;
+}
+
+/**
+ * Whether a plain ↑ restores the queued messages rather than reaching the
+ * editor. Only on a first line that fits one row of `layoutWidth`: pi's
+ * public API does not say which visual row the cursor is on, so on a wrapped
+ * first line ↑ is left to pi (it moves the cursor) and alt+up restores.
+ */
+export function upEditsQueue(editor: QueueEditEditor, queued: boolean, layoutWidth: number): boolean {
+	if (!queued) return false;
+	if (editor.isShowingAutocomplete()) return false;
+	if (editor.getCursor().line !== 0) return false;
+	return visibleWidth(editor.getLines()[0] ?? "") <= layoutWidth;
+}

package/extensions/branding/replaced-builtins.ts

@@ -0,0 +1,68 @@
+/**
+ * pi 0.99's built-in tool search and MCP, at startup (lib/replaced-builtins.mjs
+ * has the rule; decisions/tools.md "pi's built-in tool search and MCP").
+ *
+ * On the user's own pi, while the user's settings leave a built-in on, One
+ * Code asks once whether to turn them off, explaining why. "Yes" writes the
+ * `-builtin:<name>` entries through pi's own SettingsManager (a locked write
+ * of the `extensions` field only, so pi's in-memory settings keep theirs).
+ * "No" is remembered in `~/.onecode/settings.json` and never asked again;
+ * Escape asks again next start. Without a yes, the one-line notice answers
+ * pi's warning instead. Under the bundled app, which turns them off itself,
+ * a built-in left on is the user's own `+` entry, so only the notice shows.
+ */
+
+import os from "node:os";
+import { type ExtensionContext, getAgentDir, SettingsManager, VERSION as PI_VERSION } from "@earendil-works/pi-coding-agent";
+import { configCommand, installKind, replacedBuiltinsView } from "../doctor/builtins.ts";
+import { tildify } from "../lib/paths.ts";
+import { declined, recordDeclined } from "./declined.ts";
+import { replacedBuiltinsNotice, TURN_OFF_NO, TURN_OFF_YES, turnOffPrompt, withBuiltinsTurnedOff } from "../lib/replaced-builtins.mjs";
+
+/** `~/.onecode/settings.json` key: the user answered "No" to the question. */
+export const DECLINED_KEY = "piBuiltinsTurnOffDeclined";
+
+/** Ask, or show the notice, for the built-ins the settings leave on. Never throws. */
+export async function handleReplacedBuiltins(ctx: ExtensionContext): Promise<void> {
+	try {
+		const cwd = ctx.cwd;
+		const agentDir = getAgentDir();
+		const settings = () => SettingsManager.create(cwd, agentDir);
+		const view = replacedBuiltinsView(PI_VERSION, settings, { agentDir, cwd });
+		if (!view || view.left.length === 0) return;
+		const install = installKind();
+		const command = configCommand(install);
+		const notice = () => {
+			const text = replacedBuiltinsNotice(view.left, command);
+			if (text) ctx.ui.notify(text, "info");
+		};
+		// Only the user's own file is ours to offer: a project's `+builtin` entry stays.
+		const userScoped = view.left.filter((builtin) => builtin.scope === "user");
+		if (install === "app" || !ctx.hasUI || userScoped.length === 0 || declined(DECLINED_KEY)) return notice();
+
+		const shown = tildify(view.paths.user, os.homedir());
+		const choice = await ctx.ui.select(turnOffPrompt(userScoped, shown, command), [TURN_OFF_YES, TURN_OFF_NO]);
+		if (choice === TURN_OFF_YES) {
+			const manager = settings();
+			manager.setExtensionPaths(withBuiltinsTurnedOff(manager.getGlobalSettings().extensions, userScoped.map((builtin) => builtin.name)) as string[]);
+			await manager.flush();
+			const turnedOff = `Turned off pi's built-in ${userScoped.map((builtin) => builtin.name).join(" and ")} in ${shown}.`;
+			// A project's `+builtin` entry still wins over the user's file, so its warning stays.
+			const projectScoped = view.left.filter((builtin) => builtin.scope === "project");
+			const rest =
+				projectScoped.length === 0
+					? "pi's warnings stop from the next start."
+					: `This project's settings keep ${projectScoped.map((builtin) => builtin.name).join(" and ")} on, so pi still warns about ${projectScoped.length > 1 ? "them" : "it"}; run /doctor for that change.`;
+			ctx.ui.notify(`${turnedOff} ${rest}`, "info");
+			return;
+		}
+		if (choice === TURN_OFF_NO) recordDeclined(DECLINED_KEY);
+		notice();
+	} catch (error) {
+		try {
+			ctx.ui.notify(`Could not turn off pi's built-in tool search and MCP: ${(error as Error).message}. Run /doctor for the settings change.`, "warning");
+		} catch {
+			// The session ended while the dialog was open: nothing is left to tell.
+		}
+	}
+}

package/extensions/branding/startup.ts

@@ -2,8 +2,8 @@
  * 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
+ * [Extensions] block (20 internal module names) means `quietStartup`, which
+ * hides the whole listing. 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
@@ -12,11 +12,14 @@
  * 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 { existsSync, readdirSync } from "node:fs";
+import { basename, join, relative } from "node:path";
+import os from "node:os";
+import { projectInstructionFiles } from "../lib/claude-context.ts";
+import { projectConfigDir, userConfigDir } from "../lib/config-mode.ts";
+import { BUNDLED_SKILLS_DIR, scanSkills } from "../lib/skill-scan.ts";
 import { defaultDiscoverRoots, discoverPlugins } from "../lib/plugins.ts";
-import { claudeUserDir } from "../lib/paths.ts";
+import { oneCodeStateDir } from "../lib/paths.ts";
 
 export interface StartupSection {
 	label: string;
@@ -25,69 +28,29 @@ export interface StartupSection {
 
 /**
  * The project context files One Code actually gathers, from cwd up to the git
- * root (or just cwd outside a repo), for the startup banner. Mirrors what the
- * blocks send: a directory's CLAUDE.md, or its AGENTS.md when it has no CLAUDE.md
- * (CLAUDE.md > AGENTS.md), plus CLAUDE.local.md and ONECODE.md when present — so
- * AGENTS.md is listed only when it's really in play, not whenever it exists.
+ * root (or just cwd outside a repo), nearest directory first, for the startup
+ * banner. The same discovery and rule the blocks use (lib/claude-context.ts),
+ * so an AGENTS.md is listed only when it is really in play.
  */
-export function contextFileNames(cwd: string): string[] {
-	const stop = findGitRoot(cwd) ?? cwd;
-	const found: string[] = [];
-	let dir = cwd;
-	while (true) {
-		const rel = (name: string) => relative(cwd, join(dir, name)) || name;
-		const present = (name: string) => existsSync(join(dir, name));
-		// CLAUDE.md is primary; AGENTS.md stands in only when there is no CLAUDE.md.
-		if (present("CLAUDE.md")) found.push(rel("CLAUDE.md"));
-		else if (present("AGENTS.md")) found.push(rel("AGENTS.md"));
-		if (present("CLAUDE.local.md")) found.push(rel("CLAUDE.local.md"));
-		for (const name of ["ONECODE.md", "onecode.md", "One Code.md"]) {
-			if (present(name)) {
-				found.push(rel(name));
-				break;
-			}
-		}
-		if (dir === stop) break;
-		const parent = dirname(dir);
-		if (parent === dir) break;
-		dir = parent;
-	}
-	return found;
+export function contextFileNames(cwd: string, home: string = os.homedir()): string[] {
+	return projectInstructionFiles({ cwd, home, homeOneCodeDir: oneCodeStateDir(process.env, home) }).map((path) => relative(cwd, path) || basename(path));
 }
 
 /**
- * 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.
+ * Skills across the same sources our extensions feed to pi (lib/skill-scan.ts
+ * scanSkills: pi's own user dir, the mode's skill folders, the bundled
+ * catalog, installed plugins), each name once: the set `/skills` lists and
+ * `/doctor` counts.
  */
-export function skillNames(cwd: string, home: string, agentDir: string): string[] {
-	const dirs = [
-		join(cwd, ".claude", "skills"),
-		join(claudeUserDir(home), "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(defaultDiscoverRoots(agentDir, cwd, home)).skills) {
-		names.add(skill.name);
-	}
-	return [...names].sort((a, b) => a.localeCompare(b));
+export function skillNames(cwd: string, home: string, agentDir: string, bundledDir: string = BUNDLED_SKILLS_DIR): string[] {
+	const plugins = discoverPlugins(defaultDiscoverRoots(agentDir, cwd, home)).skills;
+	return [...new Set(scanSkills(cwd, home, agentDir, plugins, bundledDir).map((skill) => skill.name))].sort((a, b) => a.localeCompare(b));
 }
 
-/** Saved workflow names from the Claude Code layout dirs (project shadows user). */
+/** Saved workflow names from the mode's workflow 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(claudeUserDir(home), "workflows")]) {
+	for (const dir of [join(projectConfigDir(cwd), "workflows"), join(userConfigDir(home), "workflows")]) {
 		if (!existsSync(dir)) continue;
 		try {
 			for (const entry of readdirSync(dir)) {
@@ -146,20 +109,19 @@ export function shouldDefaultFlushOutputPad(settingsRaw: string | undefined): bo
 	}
 }
 
-/** 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;
-	}
+/**
+ * True when pi's own startup listing is silenced, so ours should render instead:
+ * `quietStartup: true`, or pi 1.0's `"header"`, which keeps pi's header and
+ * still hides the listing. The caller supplies pi's effective, merged value.
+ */
+export function quietStartupEnabled(value: unknown): boolean {
+	return value === true || value === "header";
 }
 
-export function collectStartupSections(cwd: string, home: string, packageThemesDir: string, agentDir: string): StartupSection[] {
+export function collectStartupSections(cwd: string, home: string, packageThemesDir: string, agentDir: string, bundledSkillsDir: string = BUNDLED_SKILLS_DIR): StartupSection[] {
 	const sections: StartupSection[] = [
-		{ label: "context", items: contextFileNames(cwd) },
-		{ label: "skills", items: skillNames(cwd, home, agentDir) },
+		{ label: "context", items: contextFileNames(cwd, home) },
+		{ label: "skills", items: skillNames(cwd, home, agentDir, bundledSkillsDir) },
 		{ label: "workflows", items: workflowNames(cwd, home) },
 		{ label: "themes", items: themeNames(packageThemesDir) },
 	];