@ia-ccun/code-agent-cli 0.0.52 → 0.0.53-beta.2

package/config/agent/extensions/ponytail.ts

@@ -0,0 +1,441 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+	readFileSync,
+	mkdirSync,
+	writeFileSync,
+} from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+// ============== 配置解析 ==============
+
+const STATUS_KEY = "ponytail-mode";
+const CUSTOM_TYPE = "ponytail-mode";
+
+const DEFAULT_MODE = "full";
+const VALID_MODES = ["off", "lite", "full", "ultra", "review"] as const;
+const RUNTIME_MODES = ["off", "lite", "full", "ultra"] as const;
+
+type ValidMode = (typeof VALID_MODES)[number];
+type RuntimeMode = (typeof RUNTIME_MODES)[number];
+type Mode = RuntimeMode | "review";
+
+function normalizeMode(mode: unknown): RuntimeMode | null {
+	if (typeof mode !== "string") return null;
+	const normalized = mode.trim().toLowerCase() as RuntimeMode;
+	return (RUNTIME_MODES as readonly string[]).includes(normalized) ? normalized : null;
+}
+
+function normalizeConfigMode(mode: unknown): ValidMode | null {
+	if (typeof mode !== "string") return null;
+	const normalized = mode.trim().toLowerCase() as ValidMode;
+	return (VALID_MODES as readonly string[]).includes(normalized) ? normalized : null;
+}
+
+function normalizePersistedMode(mode: unknown): Mode | null {
+	return normalizeMode(mode) || normalizeConfigMode(mode);
+}
+
+function getConfigDir(): string {
+	if (process.env.XDG_CONFIG_HOME) {
+		return path.join(process.env.XDG_CONFIG_HOME, "ponytail");
+	}
+	if (process.platform === "win32") {
+		return path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), "ponytail");
+	}
+	return path.join(os.homedir(), ".config", "ponytail");
+}
+
+function getConfigPath(): string {
+	return path.join(getConfigDir(), "config.json");
+}
+
+function getDefaultMode(): ValidMode {
+	const envMode = process.env.PONYTAIL_DEFAULT_MODE;
+	if (envMode && (VALID_MODES as readonly string[]).includes(envMode.toLowerCase())) {
+		return envMode.toLowerCase() as ValidMode;
+	}
+
+	try {
+		const configPath = getConfigPath();
+		const config = JSON.parse(readFileSync(configPath, "utf8")) as { defaultMode?: string };
+		if (config.defaultMode && (VALID_MODES as readonly string[]).includes(config.defaultMode.toLowerCase())) {
+			return config.defaultMode.toLowerCase() as ValidMode;
+		}
+	} catch {
+		// Config file doesn't exist or is invalid — fall through
+	}
+
+	return DEFAULT_MODE;
+}
+
+function writeDefaultMode(mode: unknown): ValidMode | null {
+	const normalized = normalizeConfigMode(mode);
+	if (!normalized) return null;
+
+	const configPath = getConfigPath();
+	mkdirSync(path.dirname(configPath), { recursive: true });
+	writeFileSync(configPath, JSON.stringify({ defaultMode: normalized }, null, 2), "utf8");
+	return normalized;
+}
+
+// ============== 指令构建 ==============
+
+const INDEPENDENT_MODES = new Set<Mode>(["review"]);
+
+const FALLBACK_INSTRUCTIONS: Record<RuntimeMode, string> = {
+	off: "",
+	lite: `PONYTAIL MODE ACTIVE — level: lite
+
+You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.
+
+## Rules (lite)
+
+- Check if the standard library or built-in features can solve this before reaching for external packages
+- Avoid unnecessary abstractions — prefer straightforward code for simple problems
+- Keep functions focused and short when possible, but don't over-simplify complex logic
+- Use existing project patterns and conventions; don't introduce new ones without need
+- Write the minimum code that works correctly — no extra features, no premature optimization
+
+## Output
+
+Code first. Briefly note any skipped optimizations or abstractions.
+If the explanation is longer than the code, delete the explanation.
+
+## When NOT to be lazy
+
+Never simplify away: input validation at trust boundaries, error handling that prevents data loss, security measures, accessibility basics, anything the user explicitly asked to keep.`,
+
+	full: `PONYTAIL MODE ACTIVE — level: full
+
+You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.
+
+## Persistence
+
+ACTIVE EVERY RESPONSE. No drift back to over-building. Still active if unsure. Off only: "stop ponytail" / "normal mode".
+
+Current level: **full**. Switch: \`/ponytail lite|full|ultra\`.
+
+## The ladder
+
+Before any code, stop at the first rung that holds:
+1. Does this need to be built at all? (YAGNI)
+2. Does the standard library do this? Use it.
+3. Does a native platform feature cover it? Use it.
+4. Does an already-installed dependency solve it? Use it.
+5. Can this be one line? Make it one line.
+6. Only then: write the minimum code that works.
+
+## Rules
+
+No abstractions that were not requested. No avoidable dependencies. No boilerplate nobody asked for. Deletion over addition. Boring over clever. Fewest files possible. Ship the lazy version and question the complex request in the same response — never stall. Between two same-size stdlib options, pick the one correct on edge cases. Mark intentional simplifications with a \`ponytail:\` comment — a shortcut with a known ceiling names the ceiling and the upgrade path in the comment.
+
+## Output
+
+Code first. Then at most three short lines: what was skipped, when to add it. If the explanation is longer than the code, delete the explanation. Explanation the user explicitly asked for is not debt, give it in full.
+
+## When NOT to be lazy
+
+Never simplify away: input validation at trust boundaries, error handling that prevents data loss, security measures, accessibility basics, the calibration real hardware needs (the platform is never the spec ideal), anything the user explicitly asked to keep. Lazy code without its check is unfinished: non-trivial logic leaves ONE runnable check behind (assert-based demo/self-check or one small test file; no frameworks). Trivial one-liners need no test.
+
+## Boundaries
+
+Ponytail governs what you build, not how you talk. "stop ponytail" or "normal mode": revert. Level persists until changed or session end.`,
+
+	ultra: `PONYTAIL MODE ACTIVE — level: ultra
+
+You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.
+
+## Persistence
+
+ACTIVE EVERY RESPONSE. No drift back to over-building. Still active if unsure. Off only: "stop ponytail" / "normal mode".
+
+Current level: **ultra**. Switch: \`/ponytail lite|full|ultra\`.
+
+## The ladder
+
+Before any code, stop at the first rung that holds:
+1. Does this need to be built at all? (YAGNI) — if the answer is no, say so and stop.
+2. Does the standard library do this? Use it.
+3. Does a native platform feature cover it? Use it.
+4. Does an already-installed dependency solve it? Use it.
+5. Can this be one line? Make it one line.
+6. Only then: write the minimum code that works.
+
+## Rules (ultra)
+
+- No new files unless absolutely necessary
+- No new dependencies, period — use what's already installed or stdlib
+- No abstractions, no interfaces, no config objects, no factories
+- Modify existing code in place; don't create new modules
+- If the user asks for something complex, build the simplest version that satisfies the core need and note what's deferred
+- "ponytail:" comment for every deliberate simplification, naming the trade-off
+
+## Output
+
+Code first. Then ONE line max: what was skipped and why. If the explanation is longer than the code, delete the explanation. Explanation the user explicitly asked for is not debt, give it in full.
+
+## When NOT to be lazy
+
+Never simplify away: input validation at trust boundaries, error handling that prevents data loss, security measures, accessibility basics, the calibration real hardware needs (the platform is never the spec ideal), anything the user explicitly asked to keep. Non-trivial logic leaves ONE runnable check behind. Trivial one-liners need no test.
+
+## Boundaries
+
+Ponytail governs what you build, not how you talk. "stop ponytail" or "normal mode": revert. Level persists until changed or session end.`,
+};
+
+function getPonytailInstructions(mode: Mode): string {
+	if (INDEPENDENT_MODES.has(mode)) {
+		return `PONYTAIL MODE ACTIVE — level: ${mode}. Behavior defined by /ponytail-${mode} skill.`;
+	}
+
+	const effectiveMode = normalizeMode(mode) || DEFAULT_MODE;
+
+	if (effectiveMode === "off") return "";
+
+	// Try to load from skills directory first
+	const skillPath = path.join(
+		process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".pi", "agent"),
+		"skills",
+		"ponytail",
+		"SKILL.md",
+	);
+
+	try {
+		const body = readFileSync(skillPath, "utf8");
+		return filterSkillBodyForMode(body, effectiveMode);
+	} catch {
+		// Fall back to embedded instructions
+		const fallback = FALLBACK_INSTRUCTIONS[effectiveMode as RuntimeMode];
+		if (fallback) {
+			return fallback;
+		}
+	}
+
+	return FALLBACK_INSTRUCTIONS.full;
+}
+
+function filterSkillBodyForMode(body: string, mode: RuntimeMode): string {
+	const withoutFrontmatter = String(body || "").replace(/^---[\s\S]*?---\s*/, "");
+
+	return withoutFrontmatter
+		.split(/\r?\n/)
+		.filter((line) => {
+			const tableLabel = line.match(/^\|\s*\*\*(.+?)\*\*\s*\|/);
+			if (tableLabel) {
+				const labelMode = normalizeMode(tableLabel[1].trim());
+				if (labelMode) return labelMode === mode;
+			}
+
+			const exampleLabel = line.match(/^-\s*([^:]+):\s*/);
+			if (exampleLabel) {
+				const labelMode = normalizeMode(exampleLabel[1].trim());
+				if (labelMode) return labelMode === mode;
+			}
+
+			return true;
+		})
+		.join("\n");
+}
+
+// ============== 命令解析 ==============
+
+interface SetModeCommand {
+	type: "set-mode";
+	mode: Mode;
+}
+
+interface StatusCommand {
+	type: "status";
+}
+
+interface SetDefaultCommand {
+	type: "set-default";
+	mode: ValidMode;
+}
+
+interface InvalidCommand {
+	type: "invalid";
+	reason: string;
+	mode?: string;
+}
+
+type ParsedCommand = SetModeCommand | StatusCommand | SetDefaultCommand | InvalidCommand;
+
+function parsePonytailCommand(text: string, defaultMode: ValidMode = DEFAULT_MODE): ParsedCommand {
+	const fallback = normalizePersistedMode(defaultMode) || DEFAULT_MODE;
+	const normalizedText = String(text || "").trim().toLowerCase();
+
+	if (!normalizedText) {
+		return { type: "set-mode", mode: fallback === "off" ? "full" : fallback };
+	}
+
+	const [primary, secondary] = normalizedText.split(/\s+/);
+
+	if (primary === "status") return { type: "status" };
+
+	if (primary === "default") {
+		const mode = normalizeConfigMode(secondary);
+		return mode ? { type: "set-default", mode } : { type: "invalid", reason: "invalid-default-mode" };
+	}
+
+	const mode = normalizeMode(primary);
+	return mode ? { type: "set-mode", mode } : { type: "invalid", reason: "invalid-mode", mode: primary };
+}
+
+// ============== Session 模式恢复 ==============
+
+function resolveSessionMode(
+	entries: unknown[] | undefined,
+	fallbackMode: ValidMode = DEFAULT_MODE,
+): Mode {
+	const fallback = normalizePersistedMode(fallbackMode) || DEFAULT_MODE;
+	if (!Array.isArray(entries)) return fallback;
+
+	for (let i = entries.length - 1; i >= 0; i -= 1) {
+		const entry = entries[i] as Record<string, unknown> | undefined;
+		if (entry?.type !== "custom" || entry?.customType !== CUSTOM_TYPE) continue;
+
+		const data = entry.data as Record<string, unknown> | undefined;
+		const mode = normalizePersistedMode(data?.mode);
+		if (mode) return mode;
+	}
+
+	return fallback;
+}
+
+// ============== 扩展主函数 ==============
+
+export default function ponytailExtension(pi: ExtensionAPI) {
+	let currentMode: Mode = DEFAULT_MODE;
+	let configuredDefaultMode: ValidMode = getDefaultMode();
+
+	const setMode = (mode: string, ctx?: ExtensionContext): void => {
+		const normalized = normalizePersistedMode(mode);
+		if (!normalized) return;
+
+		currentMode = normalized;
+		pi.appendEntry(CUSTOM_TYPE, { mode: normalized });
+
+		if (ctx?.ui) {
+			ctx.ui.notify(`Ponytail mode set to ${normalized}.`, "info");
+		}
+	};
+
+	const sendAlias = (skillName: string, _args: string, ctx?: ExtensionContext): void => {
+		if (ctx?.isIdle?.() === false) {
+			pi.sendUserMessage(skillName, { deliverAs: "followUp" });
+			if (ctx?.ui) {
+				ctx.ui.notify(`${skillName} queued as follow-up.`, "info");
+			}
+			return;
+		}
+		pi.sendUserMessage(skillName);
+	};
+
+	const updateStatus = (ctx: ExtensionContext): void => {
+		if (!ctx.hasUI) return;
+
+		if (currentMode === "off") {
+			ctx.ui.setStatus(STATUS_KEY, undefined);
+			return;
+		}
+
+		ctx.ui.setStatus(
+			STATUS_KEY,
+			ctx.ui.theme.fg("accent", `🎀 ${currentMode.toUpperCase()}`),
+		);
+	};
+
+	// 注册 /ponytail 命令
+	pi.registerCommand("ponytail", {
+		description: "Set or report Ponytail mode. Usage: /ponytail [lite|full|ultra|off|status|default <mode>]",
+		handler: async (args, ctx) => {
+			const parsed = parsePonytailCommand(args, configuredDefaultMode);
+
+			if (parsed.type === "status") {
+				ctx.ui.notify(
+					`Ponytail: current ${currentMode} • default ${configuredDefaultMode}`,
+					"info",
+				);
+				return;
+			}
+
+			if (parsed.type === "set-default") {
+				const written = writeDefaultMode(parsed.mode);
+				if (written) {
+					configuredDefaultMode = getDefaultMode();
+					const message =
+						configuredDefaultMode === written
+							? `Default Ponytail mode set to ${written}.`
+							: `Saved default ${written}, but env override keeps default at ${configuredDefaultMode}.`;
+					ctx.ui.notify(message, "info");
+				}
+				return;
+			}
+
+			if (parsed.type === "set-mode") {
+				setMode(parsed.mode, ctx);
+				updateStatus(ctx);
+				return;
+			}
+
+			ctx.ui.notify("Unknown or unsupported /ponytail mode.", "warning");
+		},
+	});
+
+	// 注册 skill 别名命令
+	pi.registerCommand("ponytail-review", {
+		description: "Run /skill:ponytail-review",
+		handler: async (_args, ctx) => sendAlias("/skill:ponytail-review", "", ctx),
+	});
+
+	pi.registerCommand("ponytail-audit", {
+		description: "Run /skill:ponytail-audit",
+		handler: async (_args, ctx) => sendAlias("/skill:ponytail-audit", "", ctx),
+	});
+
+	pi.registerCommand("ponytail-debt", {
+		description: "Run /skill:ponytail-debt",
+		handler: async (_args, ctx) => sendAlias("/skill:ponytail-debt", "", ctx),
+	});
+
+	pi.registerCommand("ponytail-help", {
+		description: "Run /skill:ponytail-help",
+		handler: async (_args, ctx) => sendAlias("/skill:ponytail-help", "", ctx),
+	});
+
+	// 监听用户输入，检测关闭指令
+	pi.on("input", async (event) => {
+		if (event?.source === "extension") return;
+
+		const text = String(event?.text || "");
+		if (currentMode !== "off" && /\b(stop ponytail|normal mode)\b/i.test(text)) {
+			setMode("off");
+		}
+	});
+
+	// Session 启动时恢复模式
+	pi.on("session_start", async (_event, ctx) => {
+		const entries =
+			ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
+		configuredDefaultMode = getDefaultMode();
+		currentMode = resolveSessionMode(entries, configuredDefaultMode);
+		updateStatus(ctx);
+	});
+
+	// Agent 启动前注入指令
+	pi.on("before_agent_start", async (event) => {
+		if (!currentMode || currentMode === "off") return;
+		const instructions = getPonytailInstructions(currentMode);
+		if (!instructions) return;
+		return { systemPrompt: `${event.systemPrompt}\n\n${instructions}` };
+	});
+
+	// Session 关闭时清理状态
+	pi.on("session_shutdown", async (_event, ctx) => {
+		if (ctx.hasUI) {
+			ctx.ui.setStatus(STATUS_KEY, undefined);
+		}
+	});
+}