@ryan_nookpi/pi-extension-auto-name 0.1.0 → 0.1.2

package/README.md

@@ -1,15 +1,28 @@
 # @ryan_nookpi/pi-extension-auto-name
 
-Auto session name extension for pi.
+This extension automatically names a pi session based on the first user message.
+
+It helps you quickly recognize what each session is about when many tasks are open at once.
 
 ## Install
 
 ```bash
-pi install /Users/creatrip/Documents/pi-extension/packages/auto-name
 pi install npm:@ryan_nookpi/pi-extension-auto-name
 ```
 
-## What it provides
+## Great for
+
+- quickly understanding what a session is about
+- avoiding manual naming with `/name`
+- showing the current task clearly in the terminal title and status area
+
+## How it works
+
+- It reads the first user message and generates a short session name.
+- The generated name is applied to the session name, status area, and terminal title.
+- If a session already has a name, it does not overwrite it.
+- It skips automatic naming for subagent sessions.
+
+## Example
 
-- Automatic session name detection
-- `./index.ts` entry
+If the first request is something like `Prepare a pre-release checklist`, pi can automatically turn that into a short session title.

package/index.ts

@@ -43,11 +43,8 @@ export default function autoSessionName(pi: ExtensionAPI) {
 		if (!ctx.hasUI) return;
 		const cwdBasename = path.basename(process.cwd());
 		const name = pi.getSessionName();
-		if (name) {
-			ctx.ui.setTitle(`π - ${name} - ${cwdBasename}`);
-		} else {
-			ctx.ui.setTitle(`π - ${cwdBasename}`);
-		}
+		if (!name) return;
+		ctx.ui.setTitle(`π - ${name} - ${cwdBasename}`);
 	};
 
 	const updateStatus = (ctx: ExtensionContext) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryan_nookpi/pi-extension-auto-name",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Auto session name extension for pi.",
   "type": "module",
   "keywords": [

package/utils/auto-name-utils.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import {
+	buildNameContext,
+	extractNameFromResult,
+	extractSessionFilePath,
+	formatNameStatus,
+	isSubagentSessionPath,
+	isSuccessfulResult,
+	MAX_MESSAGE_LENGTH,
+	MAX_NAME_LENGTH,
+	MAX_STATUS_CHARS,
+	SUBAGENT_SESSION_DIR,
+} from "./auto-name-utils.ts";
+
+describe("auto-name utils", () => {
+	it("detects subagent session paths", () => {
+		expect(isSubagentSessionPath(`${SUBAGENT_SESSION_DIR}/child/session.json`)).toBe(true);
+		expect(isSubagentSessionPath("/tmp/session.json")).toBe(false);
+		expect(isSubagentSessionPath(undefined)).toBe(false);
+	});
+
+	it("extracts and sanitizes the session file path", () => {
+		const sessionManager = {
+			getSessionFile: () => "\n /tmp/example.json \t",
+		};
+		expect(extractSessionFilePath(sessionManager)).toBe("/tmp/example.json");
+		expect(extractSessionFilePath({ getSessionFile: () => undefined })).toBeUndefined();
+		expect(extractSessionFilePath({ getSessionFile: "nope" })).toBeUndefined();
+		expect(extractSessionFilePath(null)).toBeUndefined();
+		expect(
+			extractSessionFilePath({
+				getSessionFile: () => {
+					throw new Error("boom");
+				},
+			}),
+		).toBeUndefined();
+	});
+
+	it("formats the status line into a single clipped line", () => {
+		const noisy = `  alpha\n beta\t${"x".repeat(MAX_STATUS_CHARS)}  `;
+		const formatted = formatNameStatus(noisy);
+		expect(formatted).not.toContain("\n");
+		expect(formatted.length).toBeLessThanOrEqual(MAX_STATUS_CHARS);
+	});
+
+	it("builds the name context with truncation", () => {
+		const message = "m".repeat(MAX_MESSAGE_LENGTH + 25);
+		const context = buildNameContext(message);
+		expect(context).toBe(`사용자 메시지: ${message.slice(0, MAX_MESSAGE_LENGTH)}`);
+	});
+
+	it("extracts text-only content and clips the result length", () => {
+		const result = extractNameFromResult([
+			{ type: "text", text: `  ${"a".repeat(MAX_NAME_LENGTH)} ` },
+			{ type: "image", text: "ignored" },
+			{ type: "text", text: "suffix" },
+		]);
+		expect(result).toBe(`${"a".repeat(MAX_NAME_LENGTH)}`);
+	});
+
+	it("accepts only fully stopped model results", () => {
+		expect(isSuccessfulResult("stop")).toBe(true);
+		expect(isSuccessfulResult("length")).toBe(false);
+		expect(isSuccessfulResult(undefined)).toBe(false);
+	});
+});

package/utils/short-label.test.ts

@@ -0,0 +1,155 @@
+import { completeSimple } from "@mariozechner/pi-ai";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { generateShortLabel, type ShortLabelContext } from "./short-label.ts";
+
+vi.mock("@mariozechner/pi-ai", () => ({
+	completeSimple: vi.fn(),
+}));
+
+const model = { id: "test-model" } as NonNullable<ShortLabelContext["model"]>;
+type CompleteSimpleResult = Awaited<ReturnType<typeof completeSimple>>;
+
+describe("generateShortLabel", () => {
+	beforeEach(() => {
+		vi.mocked(completeSimple).mockReset();
+	});
+
+	afterEach(() => {
+		vi.useRealTimers();
+	});
+
+	it("returns an empty string when model information or auth is unavailable", async () => {
+		expect(
+			await generateShortLabel(
+				{},
+				{
+					systemPrompt: "system",
+					prompt: "prompt",
+				},
+			),
+		).toBe("");
+
+		const label = await generateShortLabel(
+			{
+				model,
+				modelRegistry: {
+					getApiKeyAndHeaders: async () => ({ ok: false }),
+				},
+			},
+			{
+				systemPrompt: "system",
+				prompt: "prompt",
+			},
+		);
+
+		expect(label).toBe("");
+		expect(completeSimple).not.toHaveBeenCalled();
+	});
+
+	it("returns extracted text for successful completions", async () => {
+		vi.mocked(completeSimple).mockResolvedValue({
+			stopReason: "stop",
+			content: [
+				{ type: "text", text: "first" },
+				{ type: "text", text: " second" },
+			],
+		} as CompleteSimpleResult);
+
+		const label = await generateShortLabel(
+			{
+				model,
+				modelRegistry: {
+					getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "secret" }),
+				},
+			},
+			{
+				systemPrompt: "system",
+				prompt: "prompt",
+			},
+		);
+
+		expect(label).toBe("first second");
+		expect(completeSimple).toHaveBeenCalledTimes(1);
+	});
+
+	it("ignores incomplete model responses", async () => {
+		vi.mocked(completeSimple).mockResolvedValue({
+			stopReason: "length",
+			content: [{ type: "text", text: "ignored" }],
+		} as CompleteSimpleResult);
+
+		const label = await generateShortLabel(
+			{
+				model,
+				modelRegistry: {
+					getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "secret" }),
+				},
+			},
+			{
+				systemPrompt: "system",
+				prompt: "prompt",
+			},
+		);
+
+		expect(label).toBe("");
+	});
+
+	it("falls back to the default text extractor and handles provider errors", async () => {
+		vi.mocked(completeSimple)
+			.mockResolvedValueOnce({
+				stopReason: "stop",
+				content: [
+					{ type: "image", text: "ignored" },
+					{ type: "text", text: " label " },
+				],
+			} as CompleteSimpleResult)
+			.mockRejectedValueOnce(new Error("network"));
+
+		const ctx = {
+			model,
+			modelRegistry: {
+				getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "secret", headers: { foo: "bar" } }),
+			},
+		};
+
+		const label = await generateShortLabel(ctx, {
+			systemPrompt: "system",
+			prompt: "prompt",
+			maxTokens: 10,
+		});
+		const failed = await generateShortLabel(ctx, {
+			systemPrompt: "system",
+			prompt: "prompt",
+		});
+
+		expect(label).toBe("label");
+		expect(failed).toBe("");
+	});
+
+	it("aborts when the timeout elapses", async () => {
+		vi.useFakeTimers();
+		vi.mocked(completeSimple).mockImplementation(
+			async (_model, _context, options) =>
+				new Promise((_, reject) => {
+					options?.signal?.addEventListener("abort", () => reject(new Error("aborted")));
+				}),
+		);
+
+		const promise = generateShortLabel(
+			{
+				model,
+				modelRegistry: {
+					getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "secret" }),
+				},
+			},
+			{
+				systemPrompt: "system",
+				prompt: "prompt",
+				timeoutMs: 5,
+			},
+		);
+
+		await vi.advanceTimersByTimeAsync(5);
+		await expect(promise).resolves.toBe("");
+	});
+});