@ryan_nookpi/pi-extension-auto-name 0.1.3 → 0.2.0

package/README.md

@@ -16,6 +16,33 @@ pi install npm:@ryan_nookpi/pi-extension-auto-name
 - avoiding manual naming with `/name`
 - showing the current task clearly in the terminal title and status area
 
+## Configuration
+
+You can customize the model and reasoning level used for name generation.
+
+### `/auto-name:setting`
+
+Show current settings:
+```
+/auto-name:setting
+```
+
+Set a specific model (must be `provider/model-id` format):
+```
+/auto-name:setting model anthropic/claude-sonnet-4-20250514
+```
+
+Set thinking level (affects name generation quality vs speed):
+```
+/auto-name:setting thinking minimal
+```
+
+Available thinking levels: `minimal` (default), `low`, `medium`, `high`, `xhigh`.
+
+Settings are saved to `~/.pi/agent/auto-name/settings.json` and persist across sessions.
+
+If no custom model is set, the extension uses the current session's model.
+
 ## How it works
 
 - It reads the first user message and generates a short session name.

package/index.ts

@@ -6,6 +6,7 @@
  * - Footer display: shows session name in status bar via setStatus()
  * - Manual control: use built-in /name command (no custom command needed)
  * - Skips auto-detection for subagent sessions
+ * - Configurable model / thinking level via /auto-name:setting
  */
 
 import * as path from "node:path";
@@ -18,6 +19,7 @@ import {
 	isSubagentSessionPath,
 	NAME_SYSTEM_PROMPT,
 } from "./utils/auto-name-utils.ts";
+import { formatSettings, loadSettings, setSetting, type ThinkingLevel } from "./utils/settings.ts";
 import { generateShortLabel } from "./utils/short-label.js";
 import { NAME_STATUS_KEY } from "./utils/status-keys.ts";
 
@@ -28,12 +30,33 @@ function isSubagentSession(ctx: ExtensionContext): boolean {
 	return isSubagentSessionPath(sessionFilePath);
 }
 
+function resolveModel(ctx: ExtensionContext) {
+	const settings = loadSettings();
+	if (settings.modelId) {
+		const parts = settings.modelId.split("/");
+		if (parts.length === 2) {
+			const [provider, modelId] = parts;
+			const m = ctx.modelRegistry.find(provider, modelId);
+			if (m) return m;
+		}
+	}
+	return ctx.model;
+}
+
 async function detectNameFromMessage(userMessage: string, ctx: ExtensionContext): Promise<string> {
-	return generateShortLabel(ctx, {
-		systemPrompt: NAME_SYSTEM_PROMPT,
-		prompt: buildNameContext(userMessage),
-		extractText: extractNameFromResult,
-	});
+	const settings = loadSettings();
+	const model = resolveModel(ctx);
+	if (!model) return "";
+
+	return generateShortLabel(
+		{ model, modelRegistry: ctx.modelRegistry },
+		{
+			systemPrompt: NAME_SYSTEM_PROMPT,
+			prompt: buildNameContext(userMessage),
+			reasoning: settings.thinkingLevel ?? "minimal",
+			extractText: extractNameFromResult,
+		},
+	);
 }
 
 // ── Extension ────────────────────────────────────────────────────────────────
@@ -85,6 +108,63 @@ export default function autoSessionName(pi: ExtensionAPI) {
 		})();
 	});
 
+	// ── Command: /auto-name:setting ─────────────────────────────
+
+	pi.registerCommand("auto-name:setting", {
+		description: "Configure auto-name model and thinking level. Usage: /auto-name:setting [model|thinking] [value]",
+		handler: async (args, ctx) => {
+			if (!ctx.hasUI) return;
+			const tokens = args.trim().split(/\s+/);
+			const subCommand = tokens[0];
+
+			// 값 없이 입력하면 현재 설정 표시
+			if (!subCommand) {
+				const settings = loadSettings();
+				ctx.ui.notify(formatSettings(settings), "info");
+				return;
+			}
+
+			if (subCommand === "model") {
+				const modelId = tokens.slice(1).join(" ").trim();
+				if (!modelId) {
+					ctx.ui.notify(
+						"사용법: /auto-name:setting model <provider/model-id> (예: anthropic/claude-sonnet-4-20250514)",
+						"warning",
+					);
+					return;
+				}
+				const parts = modelId.split("/");
+				if (parts.length !== 2) {
+					ctx.ui.notify('모델 ID는 "provider/model-id" 형식이어야 합니다. (예: openai/gpt-4o)', "warning");
+					return;
+				}
+				const [provider, id] = parts;
+				const m = ctx.modelRegistry.find(provider, id);
+				if (!m) {
+					ctx.ui.notify(`모델을 찾을 수 없습니다: ${modelId}`, "error");
+					return;
+				}
+				setSetting("modelId", modelId);
+				ctx.ui.notify(`auto-name 모델이 설정되었습니다: ${m.name} (${modelId})`, "info");
+				return;
+			}
+
+			if (subCommand === "thinking") {
+				const level = tokens[1]?.trim() as ThinkingLevel | undefined;
+				const validLevels: ThinkingLevel[] = ["minimal", "low", "medium", "high", "xhigh"];
+				if (!level || !validLevels.includes(level)) {
+					ctx.ui.notify(`사용법: /auto-name:setting thinking <${validLevels.join("|")}>`, "warning");
+					return;
+				}
+				setSetting("thinkingLevel", level);
+				ctx.ui.notify(`auto-name 추론 레벨이 설정되었습니다: ${level}`, "info");
+				return;
+			}
+
+			ctx.ui.notify(`알 수 없는 설정: ${subCommand}. 사용 가능: model, thinking`, "warning");
+		},
+	});
+
 	// ── Lifecycle ─────────────────────────────────────────────────
 
 	pi.on("session_start", async (_event, ctx) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryan_nookpi/pi-extension-auto-name",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Auto session name extension for pi.",
   "license": "MIT",
   "repository": {

package/utils/settings.test.ts

@@ -0,0 +1,109 @@
+import * as fs from "node:fs";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	formatSettings,
+	getSetting,
+	loadSettings,
+	SETTINGS_DIR,
+	SETTINGS_FILE,
+	saveSettings,
+	setSetting,
+} from "./settings.ts";
+
+vi.mock("node:fs", () => ({
+	mkdirSync: vi.fn(),
+	readFileSync: vi.fn(),
+	writeFileSync: vi.fn(),
+}));
+
+function resetMocks() {
+	vi.mocked(fs.readFileSync).mockReset();
+	vi.mocked(fs.writeFileSync).mockReset();
+	vi.mocked(fs.mkdirSync).mockReset();
+}
+
+describe("settings", () => {
+	beforeEach(() => {
+		resetMocks();
+	});
+
+	it("loads default settings when file does not exist", () => {
+		vi.mocked(fs.readFileSync).mockImplementation(() => {
+			throw new Error("ENOENT");
+		});
+		const s = loadSettings();
+		expect(s).toEqual({});
+	});
+
+	it("loads parsed settings from file", () => {
+		vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ modelId: "openai/gpt-4o", thinkingLevel: "high" }));
+		const s = loadSettings();
+		expect(s.modelId).toBe("openai/gpt-4o");
+		expect(s.thinkingLevel).toBe("high");
+	});
+
+	it("loads default on invalid json", () => {
+		vi.mocked(fs.readFileSync).mockReturnValue("not-json");
+		const s = loadSettings();
+		expect(s).toEqual({});
+	});
+
+	it("loads default on non-object parse", () => {
+		vi.mocked(fs.readFileSync).mockReturnValue("123");
+		const s = loadSettings();
+		expect(s).toEqual({});
+	});
+
+	it("saves settings to correct path", () => {
+		saveSettings({ modelId: "anthropic/claude-sonnet-4" });
+		expect(fs.mkdirSync).toHaveBeenCalledWith(SETTINGS_DIR, { recursive: true });
+		expect(fs.writeFileSync).toHaveBeenCalledWith(
+			SETTINGS_FILE,
+			JSON.stringify({ modelId: "anthropic/claude-sonnet-4" }, null, 2),
+			"utf-8",
+		);
+	});
+
+	it("setSetting adds a new key", () => {
+		vi.mocked(fs.readFileSync).mockImplementation(() => {
+			throw new Error("ENOENT");
+		});
+		setSetting("thinkingLevel", "medium");
+		expect(fs.writeFileSync).toHaveBeenCalled();
+		const written = JSON.parse(vi.mocked(fs.writeFileSync).mock.calls[0][1] as string);
+		expect(written.thinkingLevel).toBe("medium");
+	});
+
+	it("setSetting removes key when value is undefined", () => {
+		vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ modelId: "a/b", thinkingLevel: "low" }));
+		setSetting("thinkingLevel", undefined);
+		const written = JSON.parse(vi.mocked(fs.writeFileSync).mock.calls[0][1] as string);
+		expect(written).not.toHaveProperty("thinkingLevel");
+		expect(written.modelId).toBe("a/b");
+	});
+
+	it("setSetting updates existing key", () => {
+		vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ thinkingLevel: "low" }));
+		setSetting("thinkingLevel", "high");
+		const written = JSON.parse(vi.mocked(fs.writeFileSync).mock.calls[0][1] as string);
+		expect(written.thinkingLevel).toBe("high");
+	});
+
+	it("formatSettings shows defaults when unset", () => {
+		const text = formatSettings({});
+		expect(text).toContain("기본 (현재 세션 모델)");
+		expect(text).toContain("기본 (minimal)");
+	});
+
+	it("formatSettings shows configured values", () => {
+		const text = formatSettings({ modelId: "openai/gpt-4o", thinkingLevel: "high" });
+		expect(text).toContain("openai/gpt-4o");
+		expect(text).toContain("high");
+	});
+
+	it("getSetting retrieves a specific value", () => {
+		vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ modelId: "openai/gpt-4o", thinkingLevel: "high" }));
+		const val = getSetting("thinkingLevel");
+		expect(val).toBe("high");
+	});
+});

package/utils/settings.ts

@@ -0,0 +1,61 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+export type ThinkingLevel = "minimal" | "low" | "medium" | "high" | "xhigh";
+
+export const SETTINGS_DIR = path.join(os.homedir(), ".pi", "agent", "auto-name");
+export const SETTINGS_FILE = path.join(SETTINGS_DIR, "settings.json");
+
+export interface AutoNameSettings {
+	/** Model identifier in "provider/model-id" format */
+	modelId?: string;
+	/** Thinking/reasoning level for name generation */
+	thinkingLevel?: ThinkingLevel;
+}
+
+const DEFAULT_SETTINGS: AutoNameSettings = {};
+
+function loadRaw(): AutoNameSettings {
+	try {
+		const data = fs.readFileSync(SETTINGS_FILE, "utf-8");
+		const parsed = JSON.parse(data) as unknown;
+		if (parsed && typeof parsed === "object") {
+			return parsed as AutoNameSettings;
+		}
+	} catch {
+		// 파일이 없거나 JSON 파싱 실패 시 기본값 사용
+	}
+	return { ...DEFAULT_SETTINGS };
+}
+
+export function loadSettings(): AutoNameSettings {
+	return loadRaw();
+}
+
+export function saveSettings(settings: AutoNameSettings): void {
+	fs.mkdirSync(SETTINGS_DIR, { recursive: true });
+	fs.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2), "utf-8");
+}
+
+export function getSetting<K extends keyof AutoNameSettings>(key: K): AutoNameSettings[K] {
+	return loadRaw()[key];
+}
+
+export function setSetting<K extends keyof AutoNameSettings>(key: K, value: AutoNameSettings[K]): void {
+	const settings = loadRaw();
+	if (value === undefined) {
+		delete settings[key];
+	} else {
+		settings[key] = value;
+	}
+	saveSettings(settings);
+}
+
+/** 현재 설정값을 사람이 읽기 좋은 문자열로 포맷팅 */
+export function formatSettings(settings: AutoNameSettings): string {
+	const lines: string[] = [];
+	lines.push(`모델: ${settings.modelId ?? "기본 (현재 세션 모델)"}`);
+	lines.push(`추론 레벨: ${settings.thinkingLevel ?? "기본 (minimal)"}`);
+	return lines.join("\n");
+}

package/utils/short-label.ts

@@ -1,4 +1,5 @@
 import { completeSimple } from "@mariozechner/pi-ai";
+import type { ThinkingLevel } from "./settings.ts";
 
 type SummaryModel = Parameters<typeof completeSimple>[0];
 type SummaryResult = Awaited<ReturnType<typeof completeSimple>>;
@@ -21,6 +22,8 @@ export type GenerateShortLabelOptions = {
 	prompt: string;
 	maxTokens?: number;
 	timeoutMs?: number;
+	/** 추론 레벨 (기본값: "minimal") */
+	reasoning?: ThinkingLevel;
 	extractText?: (content: SummaryResult["content"]) => string;
 };
 
@@ -60,7 +63,7 @@ export async function generateShortLabel(ctx: ShortLabelContext, options: Genera
 				apiKey: auth.apiKey,
 				headers: auth.headers,
 				signal: controller.signal,
-				reasoning: "minimal",
+				reasoning: options.reasoning ?? "minimal",
 				maxTokens: options.maxTokens ?? 60,
 			},
 		);