@bacnh85/pi-serena 0.4.0 → 0.4.2

package/README.md

@@ -37,6 +37,8 @@ After install or update, restart Pi or run `/reload` in an existing Pi session.
 - `serena_get_symbols_overview`
 - `serena_find_symbol`
 - `serena_find_referencing_symbols`
+- `serena_find_declaration`
+- `serena_find_implementations`
 - `serena_replace_symbol_body`
 - `serena_insert_before_symbol`
 - `serena_insert_after_symbol`
@@ -46,10 +48,14 @@ After install or update, restart Pi or run `/reload` in an existing Pi session.
 - `serena_replace_content`
 - `serena_restart_language_server`
 - `serena_get_current_config`
+- `serena_get_diagnostics_for_file`
+- `serena_check_onboarding_performed`
 - `serena_onboarding`
 - `serena_list_memories`
 - `serena_read_memory`
 - `serena_write_memory`
+- `serena_edit_memory`
+- `serena_rename_memory`
 - `serena_delete_memory`
 
 All tool outputs are truncated to 50KB / 2000 lines to match Pi-friendly output limits. Most tools accept optional `timeout_ms`.

package/index.ts

@@ -100,6 +100,32 @@ const writeMemorySchema = Type.Object({
 	content: Type.String({ description: "Memory content to write." }),
 });
 
+const editMemorySchema = Type.Object({
+	...controlSchema,
+	memory_name: Type.String({ description: "The name of the memory to edit." }),
+	needle: Type.String({ description: "The string or regex pattern to search for." }),
+	repl: Type.String({ description: "The replacement string (verbatim)." }),
+	mode: Type.Union([Type.Literal("literal"), Type.Literal("regex")], { description: "Either 'literal' or 'regex', specifying how needle is interpreted." }),
+	allow_multiple_occurrences: Type.Optional(Type.Boolean({ description: "Whether to allow replacing multiple occurrences. If false and multiple matches are found, returns an error." })),
+});
+
+const renameMemorySchema = Type.Object({
+	...controlSchema,
+	old_name: Type.String({ description: "Current name of the memory to rename." }),
+	new_name: Type.String({ description: "New name for the memory. Use '/' to organize into topics." }),
+});
+
+const symbolRefSchema = Type.Object({
+	...controlSchema,
+	name_path: Type.String({ description: "Exact symbol name path to look up." }),
+	relative_path: Type.String({ description: "File containing the symbol, relative to project root." }),
+});
+
+const diagnosticsSchema = Type.Object({
+	...controlSchema,
+	relative_path: Type.String({ description: "File path relative to the Serena project root to get diagnostics for." }),
+});
+
 const searchPatternSchema = Type.Object({
 	...controlSchema,
 	pattern: Type.String({ description: "Pattern to search for." }),
@@ -434,6 +460,18 @@ export default function serenaToolsExtension(pi: ExtensionAPI) {
 		},
 	});
 
+	pi.registerTool({
+		name: "serena_check_onboarding_performed",
+		label: "Serena Check Onboarding",
+		description: "Check whether Serena onboarding memories exist for this project.",
+		promptSnippet: "Check whether project onboarding was already performed",
+		promptGuidelines: ["Use serena_check_onboarding_performed before relying on Serena project memories."],
+		parameters: emptyToolSchema,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return callSerena(ctx, "check_onboarding_performed", params);
+		},
+	});
+
 	pi.registerTool({
 		name: "serena_onboarding",
 		label: "Serena Onboarding",
@@ -494,6 +532,66 @@ export default function serenaToolsExtension(pi: ExtensionAPI) {
 		},
 	});
 
+	pi.registerTool({
+		name: "serena_edit_memory",
+		label: "Serena Edit Memory",
+		description: "Replace content matching a pattern in a Serena project memory using literal or regex mode.",
+		promptSnippet: "Edit a Serena project memory by replacing content matching a pattern",
+		promptGuidelines: ["Use serena_edit_memory for targeted edits to existing memories without rewriting the whole file."],
+		parameters: editMemorySchema,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return callSerena(ctx, "edit_memory", params, lockPathForProject(params));
+		},
+	});
+
+	pi.registerTool({
+		name: "serena_rename_memory",
+		label: "Serena Rename Memory",
+		description: "Rename or move a Serena project memory. Supports moving between project and global scope (e.g., renaming 'global/foo' to 'bar').",
+		promptSnippet: "Rename or move a Serena project memory",
+		promptGuidelines: ["Use serena_rename_memory to rename or reorganize memories, using '/' in the name to organize into topics."],
+		parameters: renameMemorySchema,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return callSerena(ctx, "rename_memory", params, lockPathForProject(params));
+		},
+	});
+
+	pi.registerTool({
+		name: "serena_find_declaration",
+		label: "Serena Find Declaration",
+		description: "Find the declaration/definition of a symbol using the language server backend.",
+		promptSnippet: "Find the declaration/definition of a symbol",
+		promptGuidelines: ["Use serena_find_declaration to navigate to the definition of a known symbol, e.g. to find where a function is defined."],
+		parameters: symbolRefSchema,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return callWorkerAction(ctx, "find_declaration", params);
+		},
+	});
+
+	pi.registerTool({
+		name: "serena_find_implementations",
+		label: "Serena Find Implementations",
+		description: "Find implementations of a symbol using the language server backend.",
+		promptSnippet: "Find symbols that implement the given symbol",
+		promptGuidelines: ["Use serena_find_implementations to locate implementations of interfaces, abstract methods, or base classes."],
+		parameters: symbolRefSchema,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return callWorkerAction(ctx, "find_implementations", params);
+		},
+	});
+
+	pi.registerTool({
+		name: "serena_get_diagnostics_for_file",
+		label: "Serena File Diagnostics",
+		description: "Get LSP diagnostics (errors, warnings, hints) for a file using the language server backend.",
+		promptSnippet: "Get diagnostics for a file from the language server",
+		promptGuidelines: ["Use serena_get_diagnostics_for_file to inspect compiler/IDE diagnostics for a specific file."],
+		parameters: diagnosticsSchema,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return callWorkerAction(ctx, "get_diagnostics_for_file", params);
+		},
+	});
+
 	pi.registerCommand("serena-status", {
 		description: "Show Serena worker status",
 		handler: async (args, ctx) => {
@@ -530,7 +628,7 @@ export default function serenaToolsExtension(pi: ExtensionAPI) {
 		return {
 			systemPrompt:
 				event.systemPrompt +
-				"\n\nSerena semantic tools are available for code-symbol work. For finding symbols, references, declarations, implementations, and refactoring targets, prefer serena_find_symbol / serena_get_symbols_overview / serena_find_referencing_symbols over grep/read. Use grep/read for exact text searches, docs, configs, and non-code files.",
+				"\n\nSerena semantic tools are available for code-symbol work. For finding symbols, references, declarations, implementations, and refactoring targets, prefer serena_find_symbol / serena_get_symbols_overview / serena_find_referencing_symbols / serena_find_declaration / serena_find_implementations over grep/read. Use grep/read for exact text searches, docs, configs, and non-code files.",
 		};
 	});
 
@@ -557,7 +655,7 @@ export default function serenaToolsExtension(pi: ExtensionAPI) {
 				{
 					customType: "serena-reminder",
 					content:
-						"Reminder: you are reading code files instead of using Serena semantic tools. For symbols, references, declarations, implementations, and refactoring, use serena_find_symbol / serena_get_symbols_overview / serena_find_referencing_symbols instead of more grep/read calls. Keep using read/grep for docs, configs, non-code files, and exact text searches.",
+						"Reminder: you are reading code files instead of using Serena semantic tools. For symbols, references, declarations, implementations, and refactoring, use serena_find_symbol / serena_get_symbols_overview / serena_find_referencing_symbols / serena_find_declaration / serena_find_implementations instead of more grep/read calls. Keep using read/grep for docs, configs, non-code files, and exact text searches.",
 					display: true,
 				},
 				{ deliverAs: "steer", triggerTurn: true },

package/package.json

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

package/worker.ts

@@ -187,9 +187,111 @@ def handle(req: dict[str, Any]) -> dict[str, Any]:
             return {"id": req_id, "ok": False, "tool": tool_name, "errorType": classify_error(result), "error": result, "result": result}
         return {"id": req_id, "ok": True, "tool": tool_name, "result": result}
 
+    if action in ("find_declaration", "find_implementations"):
+        return _handle_find_symbol_action(req_id, action, req)
+
+    if action == "get_diagnostics_for_file":
+        return _handle_diagnostics(req_id, req)
+
     raise ValueError(f"Unknown action: {action}")
 
 
+def _get_symbol_retriever(agent: SerenaAgent):
+    from serena.symbol import LanguageServerSymbolRetriever
+    project = agent.get_active_project_or_raise()
+    return project, LanguageServerSymbolRetriever(project)
+
+
+def _find_symbol_or_raise(retriever, name_path: str, relative_path: str):
+    return retriever.find_unique(
+        name_path, substring_matching=False, within_relative_path=relative_path
+    )
+
+
+def _format_locations(locations) -> str:
+    import json
+    result = []
+    for loc in locations:
+        uri = loc.get("uri", "")
+        range_data = loc.get("range", {})
+        start = range_data.get("start", {})
+        end = range_data.get("end", {})
+        result.append({
+            "uri": uri,
+            "range": {
+                "start": {"line": start.get("line"), "character": start.get("character")},
+                "end": {"line": end.get("line"), "character": end.get("character")},
+            },
+        })
+    return json.dumps(result, indent=2)
+
+
+def _handle_find_symbol_action(req_id, action: str, req: dict[str, Any]) -> dict[str, Any]:
+    project = str(req.get("project") or os.getcwd())
+    context = str(req.get("context") or "ide")
+    params = req.get("params") or {}
+    name_path = params.get("name_path")
+    relative_path = params.get("relative_path")
+    if not isinstance(name_path, str) or not name_path:
+        return {"id": req_id, "ok": False, "tool": action, "error": f"{action} requires string parameter 'name_path'"}
+    if not isinstance(relative_path, str) or not relative_path:
+        return {"id": req_id, "ok": False, "tool": action, "error": f"{action} requires string parameter 'relative_path'"}
+
+    agent = get_agent(project, context)
+    project_obj, retriever = _get_symbol_retriever(agent)
+    symbol = _find_symbol_or_raise(retriever, name_path, relative_path)
+
+    sym_rel_path = symbol.relative_path
+    sym_line = symbol.line
+    sym_col = symbol.column
+    if sym_rel_path is None or sym_line is None or sym_col is None:
+        return {"id": req_id, "ok": False, "tool": action, "error": f"Symbol {name_path} has no position info"}
+
+    ls_manager = project_obj.get_language_server_manager_or_raise()
+    lang_server = ls_manager.get_language_server(sym_rel_path)
+
+    if action == "find_declaration":
+        locations = lang_server.request_definition(sym_rel_path, sym_line, sym_col)
+    else:
+        locations = lang_server.request_implementation(sym_rel_path, sym_line, sym_col)
+
+    if not locations:
+        return {"id": req_id, "ok": True, "tool": action, "result": "No declarations found."}
+
+    result = _format_locations(locations)
+    return {"id": req_id, "ok": True, "tool": action, "result": result}
+
+
+def _handle_diagnostics(req_id, req: dict[str, Any]) -> dict[str, Any]:
+    project = str(req.get("project") or os.getcwd())
+    context = str(req.get("context") or "ide")
+    params = req.get("params") or {}
+    relative_path = params.get("relative_path")
+    if not isinstance(relative_path, str) or not relative_path:
+        return {"id": req_id, "ok": False, "tool": "get_diagnostics_for_file", "error": "get_diagnostics_for_file requires string parameter 'relative_path'"}
+
+    import json as _json
+    import pathlib
+    from pathlib import PurePath
+
+    agent = get_agent(project, context)
+    project_obj = agent.get_active_project_or_raise()
+    ls_manager = project_obj.get_language_server_manager_or_raise()
+    lang_server = ls_manager.get_language_server(relative_path)
+
+    try:
+        uri = pathlib.Path(str(PurePath(lang_server.repository_root_path, relative_path))).as_uri()
+        result = lang_server.server.send.text_document_diagnostic({
+            "textDocument": {"uri": uri},
+        })
+        return {"id": req_id, "ok": True, "tool": "get_diagnostics_for_file", "result": _json.dumps(result, indent=2, default=str)}
+    except AttributeError:
+        return {"id": req_id, "ok": True, "tool": "get_diagnostics_for_file", "result": _json.dumps({"note": "Language server does not support textDocument/diagnostic"})}
+    except Exception as exc:
+        return {"id": req_id, "ok": True, "tool": "get_diagnostics_for_file", "result": _json.dumps({"note": "Diagnostics request completed with no issues or language server does not support textDocument/diagnostic", "detail": str(exc)})}
+
+
+
 def main() -> int:
     try:
         for line in sys.stdin: