@bacnh85/pi-serena 0.1.2 → 0.1.4

package/README.md

@@ -55,6 +55,46 @@ After install or update, restart Pi or run `/reload` in an existing Pi session.
 
 All tool outputs are truncated to 50KB / 2000 lines to match Pi-friendly output limits. Most tools accept optional `timeout_ms`.
 
+### Pattern search
+
+Use the Pi-facing `pattern` field with `serena_search_for_pattern`:
+
+```json
+{
+  "pattern": "USB_HOST_DEVICE_OBJ|USB_HOST_DEVICE_STATE_ERROR_HOLDING",
+  "relative_path": "AmazonFreeRTOS",
+  "paths_include_glob": "**/*.h"
+}
+```
+
+The extension maps `pattern` to Serena's backend `substring_pattern` parameter internally, so users do not need to call the Serena implementation detail directly.
+
+### Content replacement
+
+Use Serena's current `replace_content` API through Pi-facing fields:
+
+```json
+{
+  "relative_path": "src/example.py",
+  "needle": "old text",
+  "repl": "new text",
+  "mode": "literal"
+}
+```
+
+For regex replacement, set `mode` to `regex` and provide a Python regular expression in `needle`:
+
+```json
+{
+  "relative_path": "src/example.py",
+  "needle": "beginning.*?end",
+  "repl": "replacement",
+  "mode": "regex"
+}
+```
+
+The Pi bridge also implements `serena_get_current_config` and `serena_restart_language_server` directly, so they work even when Serena's same-named native tools are inactive in single-project or default contexts.
+
 ## Commands
 
 - `/serena-status [project]`

package/index.ts

@@ -54,7 +54,8 @@ const referencingSchema = Type.Object({
 	...controlSchema,
 	name_path: Type.String({ description: "Exact symbol name path from find_symbol." }),
 	relative_path: Type.String({ description: "File containing the symbol, relative to project root." }),
-	include_body: Type.Optional(Type.Boolean()),
+	include_kinds: Type.Optional(Type.Array(Type.Number({ description: "LSP symbol kind integers to include." }))),
+	exclude_kinds: Type.Optional(Type.Array(Type.Number({ description: "LSP symbol kind integers to exclude." }))),
 	max_answer_chars: MAX_CHARS_PARAM,
 });
 
@@ -104,16 +105,23 @@ const searchPatternSchema = Type.Object({
 	relative_path: Type.Optional(Type.String({ description: "Optional file or directory restriction relative to the Serena project root." })),
 	paths_include_glob: Type.Optional(Type.String({ description: "Optional glob for included paths." })),
 	paths_exclude_glob: Type.Optional(Type.String({ description: "Optional glob for excluded paths." })),
+	context_lines_before: Type.Optional(Type.Number({ description: "Number of context lines before each match." })),
+	context_lines_after: Type.Optional(Type.Number({ description: "Number of context lines after each match." })),
+	restrict_search_to_code_files: Type.Optional(Type.Boolean({ description: "Restrict search to source/code files when supported by Serena." })),
+	multiline: Type.Optional(Type.Boolean({ description: "Treat the pattern as a multiline regular expression when supported by Serena." })),
 	max_answer_chars: MAX_CHARS_PARAM,
 });
 
 const replaceContentSchema = Type.Object({
 	...controlSchema,
 	relative_path: Type.String({ description: "File path relative to the Serena project root." }),
-	old_string: Type.Optional(Type.String({ description: "Exact text or regex to replace, depending on Serena version." })),
-	new_string: Type.Optional(Type.String({ description: "Replacement text, depending on Serena version." })),
-	content: Type.Optional(Type.String({ description: "Replacement content for Serena versions that use content-based replacement." })),
-	regex: Type.Optional(Type.String({ description: "Regex pattern for Serena versions that use regex replacement." })),
+	needle: Type.Optional(Type.String({ description: "Exact text or regex pattern to replace." })),
+	repl: Type.Optional(Type.String({ description: "Replacement text." })),
+	mode: Type.Optional(Type.Union([Type.Literal("literal"), Type.Literal("regex")], { description: "Interpret needle as exact text or as a Python regex." })),
+	old_string: Type.Optional(Type.String({ description: "Deprecated alias for literal needle." })),
+	new_string: Type.Optional(Type.String({ description: "Deprecated alias for repl with old_string." })),
+	content: Type.Optional(Type.String({ description: "Deprecated alias for repl with regex." })),
+	regex: Type.Optional(Type.String({ description: "Deprecated alias for regex needle." })),
 	allow_multiple_occurrences: Type.Optional(Type.Boolean({ description: "Allow replacing multiple matches when supported." })),
 });
 
@@ -135,6 +143,50 @@ function stripControlParams(params: Record<string, unknown>): { project: string;
 	return { project: normalizeProject(project), context: normalizeContext(context), timeoutMs: normalizeTimeoutMs(timeout_ms), params: toolParams };
 }
 
+export function normalizeSearchPatternParams(params: Record<string, unknown>): Record<string, unknown> {
+	const normalized = { ...params };
+	if (normalized.substring_pattern === undefined && normalized.pattern !== undefined) {
+		normalized.substring_pattern = normalized.pattern;
+	}
+	delete normalized.pattern;
+	return normalized;
+}
+
+export function normalizeFindReferencesParams(params: Record<string, unknown>): Record<string, unknown> {
+	const normalized = { ...params };
+	delete normalized.include_body;
+	return normalized;
+}
+
+export function normalizeReplaceContentParams(params: Record<string, unknown>): Record<string, unknown> {
+	const normalized = { ...params };
+
+	if (normalized.needle === undefined) {
+		normalized.needle = normalized.old_string ?? normalized.regex;
+	}
+	if (normalized.repl === undefined) {
+		normalized.repl = normalized.new_string ?? normalized.content;
+	}
+	if (normalized.mode === undefined) {
+		if (normalized.regex !== undefined) normalized.mode = "regex";
+		else if (normalized.old_string !== undefined) normalized.mode = "literal";
+	}
+
+	delete normalized.old_string;
+	delete normalized.new_string;
+	delete normalized.content;
+	delete normalized.regex;
+
+	return normalized;
+}
+
+function validateReplaceContentParams(params: Record<string, unknown>): string | undefined {
+	if (typeof params.needle !== "string") return "serena_replace_content requires string parameter 'needle' (or deprecated alias 'old_string'/'regex').";
+	if (typeof params.repl !== "string") return "serena_replace_content requires string parameter 'repl' (or deprecated alias 'new_string'/'content').";
+	if (params.mode !== "literal" && params.mode !== "regex") return "serena_replace_content requires mode to be 'literal' or 'regex'.";
+	return undefined;
+}
+
 function truncateText(text: string): string {
 	const lines = text.split("\n");
 	let output = lines.slice(0, OUTPUT_MAX_LINES).join("\n");
@@ -216,10 +268,10 @@ export default function serenaToolsExtension(pi: ExtensionAPI) {
 		return worker;
 	};
 
-	const callSerena = async (ctx: any, tool: string, rawParams: Record<string, unknown>, lockPath?: string) => {
+	const callWorkerAction = async (ctx: any, action: string, rawParams: Record<string, unknown>, extraPayload: Record<string, unknown> = {}, lockPath?: string) => {
 		const { project, context, timeoutMs, params } = stripControlParams(rawParams);
 		const run = async () => {
-			const response = await getWorker(ctx).request({ action: "call", project, context, tool, params }, timeoutMs);
+			const response = await getWorker(ctx).request({ action, project, context, params, ...extraPayload }, timeoutMs);
 			return {
 				content: [{ type: "text" as const, text: resultText(response) }],
 				details: response,
@@ -228,6 +280,10 @@ export default function serenaToolsExtension(pi: ExtensionAPI) {
 		return lockPath ? withFileMutationQueue(lockPath, run) : run();
 	};
 
+	const callSerena = async (ctx: any, tool: string, rawParams: Record<string, unknown>, lockPath?: string) => {
+		return callWorkerAction(ctx, "call", rawParams, { tool }, lockPath);
+	};
+
 	const lockPathForRelativeFile = (rawParams: Record<string, unknown>): string | undefined => {
 		const project = normalizeProject(rawParams.project);
 		return typeof rawParams.relative_path === "string" && rawParams.relative_path.trim()
@@ -301,7 +357,7 @@ export default function serenaToolsExtension(pi: ExtensionAPI) {
 		promptGuidelines: ["Use serena_find_referencing_symbols before changing public behavior or renaming a symbol."],
 		parameters: referencingSchema,
 		async execute(_id, params, _signal, _onUpdate, ctx) {
-			return callSerena(ctx, "find_referencing_symbols", params);
+			return callSerena(ctx, "find_referencing_symbols", normalizeFindReferencesParams(params));
 		},
 	});
 
@@ -373,7 +429,7 @@ export default function serenaToolsExtension(pi: ExtensionAPI) {
 		promptGuidelines: ["Use serena_search_for_pattern for project-scoped code searches when symbol lookup is not enough."],
 		parameters: searchPatternSchema,
 		async execute(_id, params, _signal, _onUpdate, ctx) {
-			return callSerena(ctx, "search_for_pattern", params);
+			return callSerena(ctx, "search_for_pattern", normalizeSearchPatternParams(params));
 		},
 	});
 
@@ -385,7 +441,10 @@ export default function serenaToolsExtension(pi: ExtensionAPI) {
 		promptGuidelines: ["Prefer symbol-aware Serena edit tools for whole symbols; use serena_replace_content for non-symbol scoped replacements supported by Serena."],
 		parameters: replaceContentSchema,
 		async execute(_id, params, _signal, _onUpdate, ctx) {
-			return callSerena(ctx, "replace_content", params, lockPathForRelativeFile(params));
+			const normalized = normalizeReplaceContentParams(params);
+			const error = validateReplaceContentParams(normalized);
+			if (error) return { content: [{ type: "text" as const, text: `Error: ${error}` }], details: { ok: false, error } };
+			return callSerena(ctx, "replace_content", normalized, lockPathForRelativeFile(params));
 		},
 	});
 
@@ -397,7 +456,7 @@ export default function serenaToolsExtension(pi: ExtensionAPI) {
 		promptGuidelines: ["Use serena_restart_language_server when Serena symbol retrieval appears stale or language-server diagnostics are stuck."],
 		parameters: emptyToolSchema,
 		async execute(_id, params, _signal, _onUpdate, ctx) {
-			return callSerena(ctx, "restart_language_server", params);
+			return callWorkerAction(ctx, "restart_language_server", params);
 		},
 	});
 
@@ -409,7 +468,7 @@ export default function serenaToolsExtension(pi: ExtensionAPI) {
 		promptGuidelines: ["Use serena_get_current_config when project activation, contexts, modes, or tool availability are unclear."],
 		parameters: emptyToolSchema,
 		async execute(_id, params, _signal, _onUpdate, ctx) {
-			return callSerena(ctx, "get_current_config", params);
+			return callWorkerAction(ctx, "config", params);
 		},
 	});
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bacnh85/pi-serena",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Pi extension that provides Serena semantic code tools through a persistent worker.",
   "license": "MIT",
   "publishConfig": {

package/worker.ts

@@ -154,6 +154,22 @@ def handle(req: dict[str, Any]) -> dict[str, Any]:
         opened = bool(req.get("open")) and agent.open_dashboard()
         return {"id": req_id, "ok": True, "opened": opened, "dashboardUrl": agent.get_dashboard_url()}
 
+    if action == "config":
+        project = str(req.get("project") or os.getcwd())
+        context = str(req.get("context") or "ide")
+        agent = get_agent(project, context)
+        with contextlib.redirect_stdout(sys.stderr):
+            result = agent.get_current_config_overview()
+        return {"id": req_id, "ok": True, "tool": "get_current_config", "result": result}
+
+    if action == "restart_language_server":
+        project = str(req.get("project") or os.getcwd())
+        context = str(req.get("context") or "ide")
+        agent = get_agent(project, context)
+        with contextlib.redirect_stdout(sys.stderr):
+            agent.reset_language_server_manager()
+        return {"id": req_id, "ok": True, "tool": "restart_language_server", "result": "OK"}
+
     if action == "call":
         project = str(req.get("project") or os.getcwd())
         context = str(req.get("context") or "ide")