pi-atuin 0.1.2 → 0.1.6

package/README.md

@@ -35,30 +35,56 @@ curl --proto '=https' --tlsv1.2 -LsSf https://setup.atuin.sh | sh
 
 # Register / login
 atuin register -u <username> -e <email>
+```
+
+pi-atuin records history into atuin automatically — no `atuin hook install pi` needed. That hook registers a conflicting `bash` tool and breaks extensions like [pi-tool-display](https://github.com/MasuRii/pi-tool-display).
+
+If you previously ran `atuin hook install pi`, remove the hook extension:
 
-# Install pi hook (tracks bash commands in atuin)
-atuin hook install pi
+```bash
+rm ~/.pi/agent/extensions/atuin.ts
+pi /reload
 ```
 
-With this, pi prompts and bash commands sync bidirectionally to atuin DB. Search in either pi or your shell.
+With atuin installed, history syncs bidirectionally. Search in either pi (↑) or your shell (`atuin search`).
 
 ### JSONL-only (no atuin)
 
-No setup needed. History stored in `~/.pi/agent/pi-history.jsonl`.
+No setup needed. Pi prompts are stored in `~/.pi/agent/pi-history.jsonl`.
+
+## What gets recorded
+
+| Source | JSONL (↑ search) | Atuin DB |
+|--------|------------------|----------|
+| Your pi prompts | Yes | Yes |
+| Agent `bash` tool calls | No | Yes (default on) |
+| Your `!` shell commands | No | Yes |
+
+- **Prompts** always go to JSONL and atuin (when installed).
+- **Agent bash** is recorded to atuin only (not mixed into ↑ prompt search). On by default; `/atuin record-agent-history` toggles it.
+- **`!` commands** are your direct shell input in pi — tracked in atuin, not JSONL.
 
 ## Usage
 
+### History search
+
 1. Press **↑** when your input is empty (or cursor is on the first line)
 2. Type to fuzzy-filter
 3. **↑↓** to navigate, **Enter** to select, **Esc** to cancel
 
-All pi prompts are recorded automatically. Supports bash, zsh, and fish.
+### Commands
+
+```text
+/atuin record-agent-history   # toggle agent bash → atuin, shows on/off
+```
+
+Settings persist in `~/.pi/agent/extensions/pi-atuin/config.json`.
 
 ## Privacy
 
 - History file permissions: `600` (owner-only)
-- Max 1,000 entries, auto-trimmed
-- Atuin calls use `execFile` (no shell injection)
+- Max 1,000 JSONL entries, auto-trimmed
+- Atuin calls use `execFile` / `pi.exec` (no shell injection)
 - No hardcoded credentials or keys
 
 ## License

package/atuin-cli.ts

@@ -0,0 +1,106 @@
+/**
+ * Shared Atuin CLI helpers for pi-atuin.
+ *
+ * Uses execFile (history-store) or pi.exec (bash-tracker) via a thin adapter.
+ */
+
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const execFileAsync = promisify(execFile);
+
+export const ATUIN_AUTHOR = "pi";
+export const ATUIN_TIMEOUT_MS = 10_000;
+
+export type AtuinExecResult = {
+	code: number;
+	stdout: string;
+	stderr: string;
+};
+
+export type AtuinExec = (
+	command: string,
+	args: string[],
+	options?: { cwd?: string; timeout?: number },
+) => Promise<AtuinExecResult>;
+
+export function createExecFileAtuinExec(): AtuinExec {
+	return async (command, args, options) => {
+		try {
+			const { stdout, stderr } = await execFileAsync(command, args, {
+				cwd: options?.cwd,
+				timeout: options?.timeout ?? ATUIN_TIMEOUT_MS,
+			});
+			return { code: 0, stdout: String(stdout), stderr: String(stderr) };
+		} catch (err: unknown) {
+			const e = err as { code?: number; stdout?: string; stderr?: string };
+			return {
+				code: typeof e.code === "number" ? e.code : 1,
+				stdout: String(e.stdout ?? ""),
+				stderr: String(e.stderr ?? ""),
+			};
+		}
+	};
+}
+
+export function createPiAtuinExec(pi: ExtensionAPI): AtuinExec {
+	return async (command, args, options) => {
+		const result = await pi.exec(command, args, {
+			cwd: options?.cwd,
+			timeout: options?.timeout ?? ATUIN_TIMEOUT_MS,
+		});
+		return {
+			code: result.code,
+			stdout: result.stdout,
+			stderr: result.stderr,
+		};
+	};
+}
+
+export async function startAtuinHistory(
+	exec: AtuinExec,
+	cwd: string,
+	command: string,
+): Promise<string | undefined> {
+	try {
+		const result = await exec(
+			"atuin",
+			["history", "start", "--author", ATUIN_AUTHOR, "--", command],
+			{ cwd, timeout: ATUIN_TIMEOUT_MS },
+		);
+		if (result.code !== 0) return undefined;
+		const id = result.stdout.trim();
+		return id.length > 0 ? id : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export async function endAtuinHistory(
+	exec: AtuinExec,
+	cwd: string,
+	historyId: string,
+	exitCode: number,
+): Promise<void> {
+	try {
+		await exec(
+			"atuin",
+			["history", "end", historyId, "--exit", String(exitCode)],
+			{ cwd, timeout: ATUIN_TIMEOUT_MS },
+		);
+	} catch {
+		// Never block pi on atuin failures.
+	}
+}
+
+export async function recordAtuinCommand(
+	exec: AtuinExec,
+	cwd: string,
+	command: string,
+	exitCode = 0,
+): Promise<void> {
+	const historyId = await startAtuinHistory(exec, cwd, command);
+	if (!historyId) return;
+	await endAtuinHistory(exec, cwd, historyId, exitCode);
+}

package/bash-exit-code.ts

@@ -0,0 +1,20 @@
+/** Derive exit code from a bash tool_result event. */
+export function parseBashExitCode(event: {
+	isError: boolean;
+	content: Array<{ type: string; text?: string }>;
+}): number {
+	if (!event.isError) return 0;
+
+	const text = event.content
+		.filter((part) => part.type === "text")
+		.map((part) => part.text ?? "")
+		.join("\n");
+
+	const exitMatch = text.match(/Command exited with code (\d+)/);
+	if (exitMatch) return Number.parseInt(exitMatch[1]!, 10);
+
+	if (text.includes("Command aborted")) return 130;
+	if (text.includes("Command timed out")) return 124;
+
+	return 1;
+}

package/bash-tracker.ts

@@ -0,0 +1,87 @@
+/**
+ * Event-based bash → atuin tracking for pi-atuin.
+ *
+ * Replaces `atuin hook install pi` without registering a conflicting `bash` tool.
+ * Compatible with pi-tool-display and other extensions that own bash rendering.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createLocalBashOperations, isToolCallEventType } from "@earendil-works/pi-coding-agent";
+import {
+	createPiAtuinExec,
+	endAtuinHistory,
+	startAtuinHistory,
+} from "./atuin-cli.js";
+import { parseBashExitCode } from "./bash-exit-code.js";
+import type { ConfigGetter } from "./commands.js";
+
+interface PendingBashHistory {
+	historyId: string;
+	cwd: string;
+}
+
+export function registerBashTracker(pi: ExtensionAPI, getConfig: ConfigGetter): void {
+	const exec = createPiAtuinExec(pi);
+	const pending = new Map<string, PendingBashHistory>();
+
+	pi.on("tool_call", async (event, ctx) => {
+		if (!getConfig().recordAgentHistory) return;
+		if (!isToolCallEventType("bash", event)) return;
+
+		const command = event.input.command?.trim();
+		if (!command) return;
+
+		const historyId = await startAtuinHistory(exec, ctx.cwd, command);
+		if (historyId) {
+			pending.set(event.toolCallId, { historyId, cwd: ctx.cwd });
+		}
+	});
+
+	pi.on("tool_result", async (event) => {
+		if (!getConfig().recordAgentHistory) return;
+		if (event.toolName !== "bash") return;
+
+		const track = pending.get(event.toolCallId);
+		if (!track) return;
+
+		pending.delete(event.toolCallId);
+		await endAtuinHistory(
+			exec,
+			track.cwd,
+			track.historyId,
+			parseBashExitCode(event),
+		);
+	});
+
+	const local = createLocalBashOperations();
+
+	pi.on("user_bash", async (event) => {
+		const historyId = await startAtuinHistory(exec, event.cwd, event.command);
+
+		return {
+			operations: {
+				async exec(command, cwd, options) {
+					let exitCode: number | null = null;
+					try {
+						const result = await local.exec(command, cwd, options);
+						exitCode = result.exitCode;
+						return result;
+					} finally {
+						if (historyId) {
+							await endAtuinHistory(
+								exec,
+								cwd,
+								historyId,
+								exitCode ?? (options.signal?.aborted ? 130 : 1),
+							);
+						}
+					}
+				},
+			},
+		};
+	});
+
+	pi.on("session_shutdown", () => {
+		pending.clear();
+	});
+}

package/commands.ts

@@ -0,0 +1,48 @@
+/**
+ * /atuin slash commands for pi-atuin.
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { PiAtuinConfig } from "./config.js";
+
+export type ConfigGetter = () => PiAtuinConfig;
+export type ConfigSetter = (next: PiAtuinConfig) => void;
+
+export function toggleRecordAgentHistory(current: boolean): boolean {
+	return !current;
+}
+
+export function formatRecordAgentHistoryStatus(enabled: boolean): string {
+	return `Agent bash history recording: ${enabled ? "on" : "off"}`;
+}
+
+export function registerAtuinCommands(
+	pi: ExtensionAPI,
+	getConfig: ConfigGetter,
+	setConfig: ConfigSetter,
+): void {
+	pi.registerCommand("atuin", {
+		description: "Toggle agent bash history recording",
+		handler: async (args, ctx) => {
+			const subcommand = args.trim().split(/\s+/)[0]?.toLowerCase();
+
+			if (subcommand !== "record-agent-history") {
+				ctx.ui.notify("/atuin record-agent-history", "info");
+				return;
+			}
+
+			toggleRecordAgentHistoryCommand(ctx, getConfig, setConfig);
+		},
+	});
+}
+
+function toggleRecordAgentHistoryCommand(
+	ctx: ExtensionCommandContext,
+	getConfig: ConfigGetter,
+	setConfig: ConfigSetter,
+): void {
+	const config = getConfig();
+	const next = toggleRecordAgentHistory(config.recordAgentHistory);
+	setConfig({ ...config, recordAgentHistory: next });
+	ctx.ui.notify(formatRecordAgentHistoryStatus(next), "info");
+}

package/config.ts

@@ -0,0 +1,55 @@
+/**
+ * pi-atuin settings persisted under ~/.pi/agent/extensions/pi-atuin/config.json
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const CONFIG_DIR = join(
+	process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent"),
+	"extensions",
+	"pi-atuin",
+);
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+export interface PiAtuinConfig {
+	/** Record agent `bash` tool calls into atuin (default: true). */
+	recordAgentHistory: boolean;
+}
+
+export const DEFAULT_CONFIG: PiAtuinConfig = {
+	recordAgentHistory: true,
+};
+
+function normalizeConfig(source: unknown): PiAtuinConfig {
+	const raw = source && typeof source === "object" ? (source as Partial<PiAtuinConfig>) : {};
+	return {
+		recordAgentHistory:
+			typeof raw.recordAgentHistory === "boolean"
+				? raw.recordAgentHistory
+				: DEFAULT_CONFIG.recordAgentHistory,
+	};
+}
+
+export function loadConfig(): PiAtuinConfig {
+	try {
+		if (!existsSync(CONFIG_FILE)) return { ...DEFAULT_CONFIG };
+		const raw = JSON.parse(readFileSync(CONFIG_FILE, "utf8")) as unknown;
+		return normalizeConfig(raw);
+	} catch {
+		return { ...DEFAULT_CONFIG };
+	}
+}
+
+export function saveConfig(config: PiAtuinConfig): void {
+	mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+	writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", {
+		encoding: "utf8",
+		mode: 0o600,
+	});
+}
+
+export function getConfigPath(): string {
+	return CONFIG_FILE;
+}

package/history-store.ts

@@ -5,14 +5,16 @@
 import { readFile, writeFile, appendFile, mkdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { fuzzySearch } from "./fuzzy-match.js";
+import { createExecFileAtuinExec, recordAtuinCommand } from "./atuin-cli.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { fuzzySearch } from "./fuzzy-match.js";
 
 const execFileAsync = promisify(execFile);
+const atuinExec = createExecFileAtuinExec();
 
 const JSONL_PATH = join(homedir(), ".pi", "agent", "pi-history.jsonl");
-const ATUIN_TIMEOUT_MS = 5_000;
+const ATUIN_READ_TIMEOUT_MS = 5_000;
 const MAX_ENTRIES = 1000;
 
 export interface HistoryEntry {
@@ -25,6 +27,26 @@ export interface HistoryEntry {
 
 let writeQueue: Promise<void> = Promise.resolve();
 
+// ponytail: in-memory dedup guard — input event may fire twice per entry.
+// prevents duplicate writes to JSONL within 5s window.
+const recentWrites = new Map<string, number>();
+const WRITE_DEDUP_MS = 5_000;
+
+export function isRecentWrite(text: string): boolean {
+	const last = recentWrites.get(text);
+	if (last && Date.now() - last < WRITE_DEDUP_MS) return true;
+	return false;
+}
+
+export function markRecentWrite(text: string): void {
+	recentWrites.set(text, Date.now());
+	// Cleanup entries older than WRITE_DEDUP_MS
+	const cutoff = Date.now() - WRITE_DEDUP_MS;
+	for (const [k, ts] of recentWrites) {
+		if (ts < cutoff) recentWrites.delete(k);
+	}
+}
+
 // ---------------------------------------------------------------------------
 // JSONL persistence
 // ---------------------------------------------------------------------------
@@ -91,7 +113,7 @@ async function readAtuinHistory(): Promise<HistoryEntry[]> {
 		const { stdout } = await execFileAsync(
 			"atuin",
 			["search", "--format", "{time}\t{command}", "--limit", "200"],
-			{ timeout: ATUIN_TIMEOUT_MS },
+			{ timeout: ATUIN_READ_TIMEOUT_MS },
 		);
 
 		const lines = stdout.split("\n").filter((l) => l.trim());
@@ -143,7 +165,7 @@ async function loadAllEntries(): Promise<HistoryEntry[]> {
 		const key = entry.text.trim();
 		const existing = seen.get(key);
 		if (!existing || Math.abs(entry.timestamp - existing.timestamp) > 5000) {
-			seen.set(`${key}-${entry.timestamp}`, entry);
+			seen.set(key, entry);
 		}
 	}
 
@@ -192,24 +214,6 @@ export function invalidateCache(): void {
 // Write back to atuin (so shell atuin search also sees pi prompts)
 // ---------------------------------------------------------------------------
 
-const ATUIN_AUTHOR = "pi";
-
 export async function writeToAtuin(text: string, cwd: string): Promise<void> {
-	try {
-		const { stdout } = await execFileAsync(
-			"atuin",
-			["history", "start", "--author", ATUIN_AUTHOR, "--", text],
-			{ cwd, timeout: ATUIN_TIMEOUT_MS },
-		);
-		const id = stdout.trim();
-		if (id) {
-			await execFileAsync(
-				"atuin",
-				["history", "end", id, "--exit", "0"],
-				{ cwd, timeout: ATUIN_TIMEOUT_MS },
-			);
-		}
-	} catch {
-		// atuin not installed or failed — silently ignore
-	}
+	await recordAtuinCommand(atuinExec, cwd, text, 0);
 }

package/index.ts

@@ -9,14 +9,30 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { CustomEditor } from "@earendil-works/pi-coding-agent";
 import { matchesKey, Key } from "@earendil-works/pi-tui";
-import { addEntry, invalidateCache, listRecent, writeToAtuin } from "./history-store.js";
+import { addEntry, invalidateCache, listRecent, writeToAtuin, isRecentWrite, markRecentWrite } from "./history-store.js";
 import { HistorySearchComponent } from "./search-ui.js";
+import { registerBashTracker } from "./bash-tracker.js";
+import { loadConfig, saveConfig } from "./config.js";
+import { registerAtuinCommands } from "./commands.js";
 
 export default function piAtuin(pi: ExtensionAPI) {
+	let config = loadConfig();
+
+	const getConfig = () => config;
+	const setConfig = (next: typeof config) => {
+		config = next;
+		saveConfig(config);
+	};
+
+	registerBashTracker(pi, getConfig);
+	registerAtuinCommands(pi, getConfig, setConfig);
 	// ---- 1. Record user inputs to history ----
 	pi.on("input", async (event, ctx) => {
 		if (event.source === "interactive" && event.text.trim()) {
 			const text = event.text.trim();
+			// Guard against duplicate input events (pi may fire input twice)
+			if (isRecentWrite(text)) return { action: "continue" as const };
+			markRecentWrite(text);
 			await addEntry(text, ctx.cwd);
 			// Also write to atuin DB so shell atuin can search pi prompts
 			writeToAtuin(text, ctx.cwd);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-atuin",
-  "version": "0.1.2",
+  "version": "0.1.6",
   "description": "Atuin-style fuzzy history search for pi. Press ↑ for interactive history.",
   "license": "MIT",
   "author": "RealAlexandreAI",

package/test/bash-tracker.test.ts

@@ -0,0 +1,60 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { parseBashExitCode } from "../bash-exit-code.ts";
+
+describe("parseBashExitCode", () => {
+	it("returns 0 for successful commands", () => {
+		assert.equal(
+			parseBashExitCode({
+				isError: false,
+				content: [{ type: "text", text: "hello\n" }],
+			}),
+			0,
+		);
+	});
+
+	it("parses explicit exit codes from bash output", () => {
+		assert.equal(
+			parseBashExitCode({
+				isError: true,
+				content: [
+					{
+						type: "text",
+						text: "something failed\n\nCommand exited with code 42",
+					},
+				],
+			}),
+			42,
+		);
+	});
+
+	it("returns 130 for aborted commands", () => {
+		assert.equal(
+			parseBashExitCode({
+				isError: true,
+				content: [{ type: "text", text: "Command aborted" }],
+			}),
+			130,
+		);
+	});
+
+	it("returns 124 for timed out commands", () => {
+		assert.equal(
+			parseBashExitCode({
+				isError: true,
+				content: [{ type: "text", text: "Command timed out after 30 seconds" }],
+			}),
+			124,
+		);
+	});
+
+	it("defaults to 1 for generic errors", () => {
+		assert.equal(
+			parseBashExitCode({
+				isError: true,
+				content: [{ type: "text", text: "unknown failure" }],
+			}),
+			1,
+		);
+	});
+});

package/test/commands.test.ts

@@ -0,0 +1,18 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+	formatRecordAgentHistoryStatus,
+	toggleRecordAgentHistory,
+} from "../commands.ts";
+
+describe("record-agent-history toggle", () => {
+	it("flips the current value", () => {
+		assert.equal(toggleRecordAgentHistory(true), false);
+		assert.equal(toggleRecordAgentHistory(false), true);
+	});
+
+	it("formats status for notify", () => {
+		assert.equal(formatRecordAgentHistoryStatus(true), "Agent bash history recording: on");
+		assert.equal(formatRecordAgentHistoryStatus(false), "Agent bash history recording: off");
+	});
+});

package/test/config.test.ts

@@ -0,0 +1,9 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { DEFAULT_CONFIG } from "../config.ts";
+
+describe("DEFAULT_CONFIG", () => {
+	it("records agent bash history by default", () => {
+		assert.equal(DEFAULT_CONFIG.recordAgentHistory, true);
+	});
+});